PythonGuides-博客中文翻译-十五-
PythonGuides 博客中文翻译（十五）
通过索引从 Python 字符串中移除字符
原文：https://pythonguides.com/remove-character-from-python-string-through-index/
在这里，我们将讨论如何以不同的方式通过索引从 Python 的字符串中删除一个字符，并讨论一些可以使用 Python 来执行它们的方法。以下是我们将要讨论的主题
- 如何使用切片和连接方法通过索引从 Python 字符串中移除字符
- 如何使用 native 方法通过索引从 Python 字符串中移除字符
- 如何使用 replace 方法通过索引从 Python 字符串中移除字符
- 如何使用拆分方法通过索引从 Python 字符串中移除字符
- 如何使用连接和列表理解方法通过索引从 Python 字符串中移除字符
目录
- 如何使用切片和拼接方法通过索引从 Python 字符串中删除字符
- 如何使用 native 方法通过 index 从 Python 字符串中删除字符
- 如何使用替换方法通过索引从 Python 字符串中删除字符
- 如何使用拆分方法通过索引从 Python 字符串中删除字符
- 如何使用连接和列表理解方法通过索引从 Python 字符串中删除字符
如何使用切片和拼接方法通过索引从 Python 字符串中删除字符
- 在这个例子中，我们将讨论如何使用 Python 中的切片和连接方法通过索引从字符串中删除字符。
- 要从元素集合中提取一部分元素，使用 Python 中的
slice()方法。 - 通过指定索引，用户可以访问特定范围的元素。使用弦切片，可以修剪位置 I 之前和位置 I 之后的弦
- 此外，您可以连接两个或多个字符串。字符串串联是使用运算符或函数来组合两个或更多字符串的过程。通过使用+运算符，我们将连接两个字符串。
举例:
让我们举一个例子，看看如何通过使用切片和连接方法，通过索引从 Python 字符串中删除一个字符。
源代码:
**# Input String**
state_name_in_USA = 'Alaska, Arizona, Alabama'
print("Input string: ",state_name_in_USA )
**# By using the slice and concatenation method** result = state_name_in_USA[:1] + state_name_in_USA[2:]
**# Removing. character at 2nd index**
print ("Removing character from second index in string : ", result)
下面是以下给定代码的实现。
How to remove a character from a Python string through index by using the slice and concatenation method
这就是我们如何使用切片和连接方法通过索引从 Python 字符串中删除字符。
如何使用 native 方法通过 index 从 Python 字符串中删除字符
- 在本节中，我们将讨论如何使用 Python 中的 native 方法通过索引从 Python 字符串中移除字符。
- 这里我们将使用 for 循环的概念，在出现字符时追加字符，并在索引为 I 时从初始 for 实例创建一个新字符串。
举例:
**# Input string**
Bikes_in_USA = "Harley-Davidson, BMW"
print("Original string :",Bikes_in_USA )
**# Removing element at index 3**
result = ""
for m in range(len(Bikes_in_USA)):
if m != 3:
result = result + Bikes_in_USA[m]
**# Display the Content**
print ("Remove character from input string by index 3 : ", result)
在下面给出的代码中，我们创建了一个名为 'Bikes_in_USA' 的输入字符串，然后创建一个空字符串来存储新的结果。接下来，我们使用 for 循环并迭代这些值。
你可以参考下面的截图。
How to remove a character from a Python string through index by using the native method
正如你在截图中看到的，我们已经通过索引使用 native 方法从 Python 字符串中删除了一个字符。
如何使用替换方法通过索引从 Python 字符串中删除字符
- 在本节中，我们将了解如何使用
replace()方法通过 Python 中的索引从字符串中删除字符。 - 在 Python 中用新字符替换单个字符时，使用
replace()方法，通过该方法，我们将替换作为(")提供的空子串的 I 索引处的字符。 - 在这个例子中，如果我们想从字符串中删除字符，那么我们必须提到索引号。
语法:
让我们看一下语法并理解 Python 中的 str.replace() 方法的工作原理。
str.replace(old, new, count)
- 它由几个参数组成
old:-该参数定义了将要被替换的字符串。new:用新值(一个字符或字符串)替换现有值。count:-一个整数值，表示要用新字符或子串替换多少个旧字符或子串。这是一个可选参数。
举例:
让我们举一个例子，看看如何使用 replace 方法通过索引从 Python 字符串中删除一个字符
源代码:
def del_character(t, m):
for l in range(len(t)):
if l==m:
t=t.replace(t[m],"",1)
return t
Country_name = "U.S.A, China"
**# Remove 3rd index character**
m = 3
print(del_character(Country_name,m-1))
在上面的代码中，我们首先定义了一个函数，它接受一个字符串和一个索引，然后移除该索引处的字符。接下来，我们执行从 0 到输入字符串长度的循环，并检查当前迭代是否等于索引 i 。如果被识别，替换索引 I 处的字符的空字符串。
你可以参考下面的截图
How to remove a character from a Python string through index by using the replace method
在这个例子中，我们已经理解了如何使用 replace 方法通过索引从 Python 字符串中删除字符。
阅读:
如何使用拆分方法通过索引从 Python 字符串中删除字符
- 在这种方法中，字符串将被分成两半，一个在索引 I 之前，另一个在索引 I 之后。不包含第 I 个字符的字符串可以通过组合这两个字符串来生成。
- 我们将使用切片的概念来分割字符串。当我们为一个字符串指定开始和结束索引时，我们可以把它分割成更小的条目。
- 通过使用切片 [i:] 我们将获得除了所选字符之外的剩余字符串。
举例:
让我们举一个例子，看看如何使用 Python 中的 splitting 方法，通过索引从 Python 字符串中删除一个字符。
源代码:
def deletechar(n, m):
val_1 = n[ : m]
val_2 = n[m + 1: ]
return val_1+val_2
Country_name = "United States of America"
print("Input string :", Country_name )
m = 4
print(deletechar(Country_name,m-1))
该字符串被分成两个子字符串，每个子字符串存储在一个单独的变量中。然后使用连接操作符 (+) 将两个子字符串连接起来。接下来，我们必须传递给 m-1 给定函数中的索引。
下面是以下给定代码的执行。
How to remove a character from a Python string through index by using the splitting method
这就是如何使用 Python 中的 splitting 方法通过索引从 Python 字符串中删除字符。
如何使用连接和列表理解方法通过索引从 Python 字符串中删除字符
- 在这一节中，我们将讨论如何使用列表理解和
join()方法通过索引从字符串中删除字符。 - 使用 Python 中的
join()方法将一个字符串和一个 iterable 对象连接起来。它返回一个产品字符串，该字符串组合了 iterable 中的所有字符串。 - 通过使用 list comprehension 和 join 方法，我们可以很容易地将每个 string 元素拆分成相关的 list 元素，然后将它们连接起来以声明一个新的 string。
- 在这种方法中，首先将每个字符串元素转换成一个列表元素，然后将它们中的每一个组合起来，创建一个除给定索引之外的字符串。
举例:
这里我们将举一个例子，了解如何通过使用 list comprehension 和 join() 方法，通过索引从字符串中删除字符。
源代码:
Country_name = "U.S.A, Germany, Australia"
print ("Input string: ", Country_name)
**# By using the join() method**
output = ''.join([Country_name [i] for i in range(len(Country_name )) if i != 2])
**# Display the Content**
print ("Character remove from 2nd position: ",output)
在上面的代码中，我们首先创建了一个名为“Country _ name”的输入字符串，并在其中为它分配了国家名称。接下来，我们使用了 join() 方法并用一个设定的条件迭代这些值，如果 i！=2 ，在本例中，I 表示索引号。
下面是以下代码的截图
How to remove a character from a Python string through index by using the join and list comprehension method
您可能也喜欢阅读以下 Python 教程。
- 删除 Python 中字符串的最后一个字符
- 如何用 Python 将列表追加到另一个列表中
- 如何在 Python 中将集合转换成列表
- 如何在 Python 中寻找完全数
- 如何在 Python 中使用 For 循环对列表中的元素求和
在本文中，我们讨论了如何以不同的方式通过索引从 Python 的字符串中删除字符，并讨论了一些可以使用 Python 来执行它们的方法。
- 如何使用切片和连接方法通过索引从 Python 字符串中移除字符
- 如何使用 native 方法通过索引从 Python 字符串中移除字符
- 如何使用 replace 方法通过索引从 Python 字符串中移除字符
- 如何使用拆分方法通过索引从 Python 字符串中移除字符
- 如何使用连接和列表理解方法通过索引从 Python 字符串中移除字符
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
从字符串 Python 中移除字符(35 个示例)
原文：https://pythonguides.com/remove-character-from-string-python/
在本 Python 教程中，我们将讨论如何从字符串 Python 中移除字符。在这里，我添加了 35 个 Python 中各种字符串操作的例子。
我们还将检查:
- Python 从字符串中删除一个字符
- Python 使用 replace()方法从字符串中删除字符
- Python 使用 replace()方法从字符串中删除多个字符
- Python 使用 translate()方法从字符串中删除字符
- Python 使用 translate()方法从字符串中删除多个字符
- 从字符串 python 中移除第一个字符
- 从字符串 python 中删除 n 个字符
- 从字符串 python 中移除换行符
- 在 python 中移除指定次数
- Python 替换一个字符串中的多个字符
- 从字符串 python 中移除字符串
- 如何从字符串 python 中移除标点符号
- 移除字符串 python 中的最后一个字符
- 从字符串 python 中移除最后 4 个字符
- Python 删除了字符串中所有空格
- Python 只删除前导和尾随空格
- 在 python 中从一个字符串中删除多个字符
- 从字符串 python 中移除空格
- python 从字符串中剥离子串
- 通过索引从字符串 python 中移除字符
- 从字符串中删除一个字符 python 熊猫
- Python 从字符串中删除一个特殊字符
- Python 从列表中的字符串中删除一个字符
- Python 从字符串中删除一个字符的所有实例
- Python 从字符串正则表达式中删除字符
- Python 从字符串开头移除字符
- Python 从字符串末尾移除字符
- python 从字符串中移除字符(如果存在)
- Python 从索引后的字符串中删除字符
- 从字符串 Python 中移除字母
- 从字符串 Python pandas 中删除多个字符
- Python 剥离前两个字符
- Python strip 最后两个字符
- 从字符串 Python 中移除*
目录
- Python 从字符串中删除一个字符
- Python 使用 replace()方法从字符串中删除一个字符
- Python 使用 replace()方法从一个字符串中删除多个字符
- Python 使用 translate()方法从字符串中删除一个字符
- Python 使用 translate()方法从字符串中删除多个字符
- 删除字符串 Python 的第一个字符
- 从字符串 python 中删除 n 个字符
- 从字符串 python 中移除换行符
- 在 python 中删除指定次数
- Python 替换一个字符串中的多个字符
- 从字符串 python 中移除字符串
- 如何删除字符串中的标点符号 python
- 删除字符串 python 的最后一个字符
- 删除字符串 python 的最后 4 个字符
- Python 删除字符串中的所有空格
- Python 只删除前导和尾随空格
- 在 python 中从一个字符串中删除多个字符
- 如何从字符串 python 中删除空格
- Python 从字符串中剥离子串
- Python 从字符串中删除指定字符
- 通过索引从字符串 Python 中删除一个字符
- 从字符串中删除一个字符 python 熊猫
- Python 从字符串中移除特殊字符
- Python 从字符串列表中删除一个字符
- Python 从字符串中移除一个字符的所有实例
- Python 从字符串正则表达式中删除一个字符
- 如何在 Python 中使用 regex 删除字符串中的多个字符
- Python 从字符串开头移除字符
- 使用 Slice()方法从字符串开头删除一个字符
- 通过使用 join()和列表理解方法
- Python 从字符串末尾移除字符
- 通过使用 split()函数删除最后一个字符
- 通过使用 rstrip()方法
- Python 删除字符串中存在的字符
- Python 从字符串中移除索引后的字符
- 从字符串 Python 中删除字母
- 从字符串中删除多个字符 Python 熊猫
- Python 剥离前两个字符
- Python 剥离最后两个字符
- 使用 strip()方法从字符串中删除最后两个字符
- 将*从字符串 Python 中移除
Python 从字符串中删除一个字符
让我们看一个 Python 从字符串中删除字符的例子。
在 Python 中，从字符串中删除字符在许多应用程序中非常有用。过滤文本，情感总是需要能够从字符串中删除一个字符的主要方法和解决方案。
-
使用 replace()和 translate()方法可以很容易地从字符串中删除一个字符。
-
要从字符串中删除一个字符，有许多方法可以解决这个问题。
-
我们将讨论以下方法。
- 使用 Python replace()方法
- 使用 translate()方法
- 使用切片方法
- 使用 join()方法
- 使用 filter()方法
-
Replace():这个函数是一个内置的字符串方法，它将一个字符替换为另一个字符，并且总是显示一个新的字符串作为结果。
语法:
下面是 replace() 方法的语法
replace
[
old_str
new_str
instance
]
Translate():该方法将通过替换字符来改变字符串。我们必须为字符生成 Unicode，并生成 None 作为替换值，以便从主字符串中删除该值。
语法:
下面是 translate() 方法的语法
str.translate(table)
存储两个字符之间映射的转换表是由 maketrans()方法创建的。
Slicing():这个方法返回介于索引 a 和 b 之间的字符。如果用户想要删除特定索引处的字符，那么我们使用 Slicing()方法。
语法:
String
[start:end:step_value]
举例:
让我们举一个例子来检查如何使用切片方法从字符串中删除字符
str="Japan"
str=str[:3]+str[4:] #remove character at index 3
print(str)
下面是以下代码的截图
Python Remove character from string using slicing method
Join():是将 iterable 对象的每个值和字符与字符串连接起来，返回一个新字符串的方法。要从字符串中删除一个字符，我们可以很容易地使用 join()方法，我们将不得不遍历字符串序列并删除该字符。
语法:
string_name.join(iterable)
举例:
让我们举一个例子来检查如何使用 join 方法从字符串中删除字符
str="Australia Germany France"
list=['a','r']
str2="".join(i for i in str if i not in list)
print(str2)
下面是以下代码的截图
Python Remove character from a string using join
Filter():Filter 方法在 join()函数的帮助下给出一个可迭代序列，该函数测试可迭代序列中的每个值和字符是否为真。
举例:
让我们举一个例子来检查如何使用 filter() 方法从字符串中删除一个字符
str="Russia England China"
remove_char=['a','i','n']
new=filter(lambda i: i not in remove_char,str)
new_str=""
for i in new:
new_str+=i
print(new_str)
下面是以下代码的截图
Python remove a character from a string using a filter
Python 使用 replace()方法从字符串中删除一个字符
- 在这个方法中，我们将学习和讨论如何使用 replace()方法从字符串中删除一个字符。
- 这个方法可以很容易地用空白字符串 char 替换任何字符。
- 我们可以使用 replace()方法用一个新的字符来删除一个字符。
- 使用""作为新字符可以很容易地从字符串中删除一个字符。
语法:
replace
[
old_str
new_str
instance
]
举例:
让我们举一个例子来检查如何使用 replace()方法从字符串中删除一个字符
str1 = "Germany France"
print(str1.replace('e','o'))
- 在上面的代码中，我们将创建一个变量并分配一个字符串，然后使用函数 str.replace()。
- 在本例中，我们将用“o”替换字符“e”。
- 如果我们生成空字符串作为第二个参数，那么这个字符将很容易从字符串中删除。
下面是以下代码的截图
Python remove a character from string using replace
阅读: Python 从字符串中移除子串
Python 使用 replace()方法从一个字符串中删除多个字符
- 在这个方法中，我们将学习和讨论如何使用 replace()方法从一个字符串中删除多个字符。
- 要从一个字符串中删除多个字符，我们可以很容易地使用函数 str.replace 并传递一个参数 multiple characters。
- String 类(Str)提供了一个 replace(old_str，new_str)的方法来替换一个字符串中的子字符串。它用新子字符串替换旧子字符串的所有元素。
语法
下面是 replace()方法的语法
replace
[
old_str
new_str
instance
]
举例:
让我们举一个例子来检查如何使用 replace 方法从字符串中删除多个字符
str = "Germany France"
result = str.replace('a', 'b').replace('e', 'u')
print(result)
下面是以下代码的截图
Python remove multiple characters from a string using replace
Python 使用 translate()方法从字符串中删除一个字符
- 在这个方法中，我们将学习和讨论如何使用 translate()方法从字符串中删除一个字符。
- 在 translate()方法中，我们必须为字符生成 Unicode 码位，并生成“None”作为替换，以便从结果字符串中删除它。
- 在 translate()中，我们可以很容易地使用 ord()函数来获取 unicode 字符。
语法:
下面是 translate() 方法的语法
str.translate(table)
maketrans()方法声明了存储两个字符之间映射的转换表。
举例:
让我们举一个例子来检查如何使用 translate 方法从字符串中删除一个字符。
str = "U.S.A southAfrica Australia "
print(str.translate({ord('r'): None}))
下面是以下代码的截图
Python remove a character from a string using translate
Python 使用 translate()方法从字符串中删除多个字符
- 在本节中，我们将学习并讨论如何使用 translate()方法从字符串中删除多个字符。
- 如果用户想要替换多个字符，可以使用序列迭代器很容易地完成，它遍历我们想要从字符串中删除的字符串。
- 我们使用列表理解方法来迭代每个字符。
语法:
下面是 translate() 方法的语法
str.translate(table)
举例:
让我们举一个例子来检查如何使用 translate()方法从一个字符串中删除多个字符。
str = "Micheal George James"
print(str.translate({ord(i): None for i in 'aeo'}))
下面是以下代码的截图
Python remove multiple characters from a string using translate
删除字符串 Python 的第一个字符
现在，我们将看看如何在 Python 中从字符串中移除的第一个字符。我们可以使用 replace()函数来删除第二个参数为空字符串的字符，然后删除该字符。
举例:
my_string = 'Welcome'
print(my_string.replace('W', '')
写完上面的代码后(从 string python 中删除第一个字符)，您将打印出 " my_string.replace() " ，然后输出将显示为 " elcome " 。这里，第一个字符是“W ”,在 python 中被替换为空字符串。
你可以参考下面的截图来删除字符串 python 中的第一个字符
Remove the first character from string python
这就是我们如何从字符串 python 中移除第一个字符。
阅读:在 Python 中把 string 转换成 float 各种例子
从字符串 python 中删除 n 个字符
现在，我们将看到如何用 Python 从字符串中移除 n 个字符。我们可以使用字符串切片“[n:]”，其中 n 表示要从字符串中删除的字符数量。
举例:
my_string = 'Welcome'
remove = my_string[3:]
print(remove)
写完上面的代码(从字符串 python 中删除 n 个字符)，你将打印出 " remove " ，然后输出将显示为 " come " 。这里，n 是 3，所以前 3 个字符从字符串 python 中删除。
你可以参考下面的截图来删除字符串 python 中的 n 字符
Remove n character from string python
这就是我们如何从字符串 python 中移除 n 个字符。
从字符串 python 中移除换行符
在 python 中，要从字符串中移除换行符，我们可以使用 replace() 函数移除字符串中的“\n ”,它将移除所有换行符。
举例:
my_string = 'Welcome\nto\n2020'
print(my_string.replace('\n', ''))
写完上面的代码后(从 string python 中去掉换行符)，你将打印出 " my_string.replace() " ，然后输出将显示为 " Welcometo2020 " 。这里，“\n”被删除，空字符串作为第二个参数，换行符从字符串中删除。
你可以参考下面的截图来删除字符串 python 中的换行
Python Remove newline from string
这就是我们如何从字符串 python 中移除换行的方法
在 python 中删除指定次数
在 python 中，要删除指定的次数，我们可以使用带有 3 个参数的 replace() 函数来指定字符串中应该发生替换的次数。
举例:
my_string = 'Welcome'
print(my_string.replace('e', 'E', 2))
写完上面的代码(在 python 中去掉指定的次数)，你将打印出 " my_string.replace() " 然后输出将显示为 " WElcomE " 。这里，“E”被删除，第二个参数是“E ”,第三个参数是替换发生的次数。
你可以参考下面的截图来删除 python 中指定的次数
Remove specified number of times in python
这就是我们如何在 python 中移除指定次数的方法。
Python 替换一个字符串中的多个字符
在 python 中，要替换一个字符串中的多个字符，我们将使用 str.replace() 来替换字符，它将使用替换的字符创建一个新字符串。
举例:
my_string = "Sixty"
remove = ['t', 'y']
for value in remove:
my_string = my_string.replace(value, '')
print(my_string)
写完上面的代码(python 替换一个字符串中的多个字符)，你将打印出 " my_string " ，然后输出将显示为 " Six " 。这里，“t”和“y”旧值被替换为空字符串 new。
你可以参考下面的 python 截图替换一个字符串中的多个字符
这就是我们如何在字符串中替换多个字符的方法。
阅读: Python 程序反转字符串示例
从字符串 python 中移除字符串
在 python 中，要从字符串中删除一个字符串，我们将使用一个 str.replace() 方法从字符串 python 中删除该字符串，它将创建一个新的字符串。
举例:
my_string = "Sixty people arrived in the hostel"
remove = ['arrived']
for value in remove:
my_string = my_string.replace(value, '')
print(my_string)
写完上面的代码后(从 string python 中移除 string)，你将打印出 " my_string " ，然后输出将显示为"酒店中的六十个人"。在这里，“到达”与空字符串一起被删除。
可以参考下面的截图 python 从字符串中移除字符串 python
这就是我们如何从字符串 python 中移除字符串的方法
如何删除字符串中的标点符号 python
在 python 中，要删除字符串 python 中的标点符号，我们将使用 for 循环来删除字符串 python 中的所有标点符号。
举例:
punctuation = '''!/?@#$%^&*_~()-[]{};:'"\,<>.'''
my_string = "Hello!? World!!"
remove_punct = ""
for character in my_string:
if character not in punctuation:
remove_punct = remove_punct + character
print(remove_punct)
写完上面的代码(如何从字符串 python 中删除标点符号)，你将打印出 " remove_punct " ，然后输出将显示为 " Hello World " 。这里，我们将使用 for 循环检查字符串的每个字符，它将删除字符串中的所有标点符号。
你可以参考下面的截图，了解如何从字符串 python 中删除标点符号
这就是我们如何从字符串中删除标点符号的方法
阅读: Python 字符串格式化示例
删除字符串 python 的最后一个字符
在 python 中，为了从字符串中移除最后一个字符，我们将使用字符串切片技术来移除最后一个字符。使用负索引 "my_string[:-1]" 将移除字符串的最后一个字符。
举例:
my_string = 'University'
remove_char = my_string[:-1]
print(remove_char)
写完上面的代码后(从字符串 python 中删除最后一个字符)，你将打印出 "remove_char " ，然后输出将显示为 " Universit " 。在这里，我们将使用负索引 -1 来删除大学中的最后一个字符。
你可以参考下面的截图删除字符串 python 中的最后一个字符
这就是我们如何从字符串 python 中移除最后一个字符的方法
删除字符串 python 的最后 4 个字符
在 python 中，为了从字符串 python 中移除最后 4 个字符，我们将使用字符串切片技术，通过使用负索引“my_string[:-4]”来移除最后 4 个字符，并且它将移除字符串的最后 4 个字符。
举例:
my_string = 'University'
remove_char = my_string[:-4]
print(remove_char)
在编写完上面的代码(从字符串 python 中删除最后 4 个字符)之后，一旦打印出 "remove_char " ，输出将显示为 " Univer" 。这里，我们将使用一个负索引 -4 来删除大学的最后 4 个字符。
你可以参考下面的截图，去掉字符串 python 中的最后 4 个字符
这就是我们如何从字符串 python 中删除最后 4 个字符
Python 删除字符串中的所有空格
在 python 中，为了删除字符串中的所有空白，我们将使用 replace() 来删除字符串中的所有空白。
举例:
my_string = " Welcome to Python "
remove = my_string.replace(" ", "")
print(remove)
写完上面的代码(python 删除字符串中的所有空格)，你将打印出 "remove" ，然后输出将显示为 " WelcometoPython " 。这里，我们将使用 replace()删除字符串中的所有空格。
你可以参考下面的截图 python 去除字符串中的所有空格
这就是我们如何从字符串 python 中移除所有空白的方法
Python 只删除前导和尾随空格
在 python 中，为了只删除前导和尾随空格，我们将使用 strip()函数从字符串的开头和结尾删除前导和尾随字符。
举例:
my_string = " Welcome to Python \n\r\t "
remove = my_string.strip()
print(remove)
写完上面的代码(python 只删除前导和尾随空格)，你将打印出“remove”，然后输出将显示为“欢迎使用 Python”。这里，我们将使用 strip()函数从字符串的开头和结尾删除前导和尾随字符以及空格。
你可以参考下面的截图 python 只删除前导和尾随空格。
这就是 python 如何只删除前导和尾随空格。
在 python 中从一个字符串中删除多个字符
- 为了从一个字符串中删除多个字符，我们将首先创建一个原始字符串的副本。
- 将需要删除的多个字符放入一个字符串中。
- 然后使用 for-loop 遍历每个字符。
- 然后调用 new_string.replace()用 new 替换 old。
举例:
o_string = "(Python@Guides)!"
characters_remove = "()@!"
new_string = o_string
for character in characters_remove:
new_string = new_string.replace(character, "")
print(new_string)
在编写了上面的代码(在 python 中从一个字符串中删除多个字符)之后，一旦您打印了“new _ string”，那么输出将显示为“python guides”。在这里，字符串中的多个字符将被删除，它将返回一个排除这些字符的新字符串。
你可以参考下面的截图在 python 中从一个字符串中删除多个字符
Remove multiple characters from a string in python
上面的代码我们可以用来在 Python 中从一个字符串中移除多个字符。
如何从字符串 python 中删除空格
在 python 中，要删除字符串中的空格，我们有 replace()方法来删除单词之间的所有空格，它将删除字符串中的空白。
举例:
string = ' Welcome to Python '
remove = string.replace(" ", "")
print(remove)
写完上面的 Python 代码(从 string python 中删除空格)，你将打印出 "remove" ，然后输出将出现 "WelcometoPython" 。这里，replace()将删除字符串中的所有空格。另外，你可以参考下面的截图。
Remove spaces from string python
上面的代码我们可以用来从字符串 python 中删除空格。
Python 从字符串中剥离子串
让我们看一个 Python 从字符串中剥离字符的例子。
python 中的 strip() 方法返回字符串的副本。它将从字符串中去除指定的字符。
举例:
my_str = "www.pythonguides"
r = my_str.strip("guides")
print(r)
在编写了上面的代码(python 从字符串中剥离字符)之后，一旦打印出“r”，输出将显示为“www .巨蟒"。这里， my_str.strip("guides") 用于从字符串中剥离字符 "guides" 。
你可以参考下面 python 从字符串中剥离字符的截图。
Python strip characters from a string
Python 从字符串中删除指定字符
- 在这一节中，我们将学习如何在 Python 中从一个字符串中移除一个指定的字符。
- Python 使用多种方法从字符串中删除一个字符，通过这些方法我们可以很容易地从字符串中删除一个字符。
- 以下是方法列表
- 字符串替换()
- 字符串翻译()
String replace() 方法用另一个指定的字符替换一个指定的字符。
语法:
下面是字符串 replace()的语法
replace[
old_Str1,
new_Str2,
instance
]
让我们举一个例子来检查如何从字符串中删除一个字符
str1 = 'john'
print(str1.replace('o',''))
下面是以下代码的截图
Python remove a character from string
String translate() :通过替换字符或删除字符来改变字符串。我们必须指定字符的 Unicode 作为替换，以便将其从字符串中删除。
让我们举一个例子来检查如何使用 translate()从字符串中删除一个字符
str1 = 'john'
print(str1.translate({ord('o'):None}))
下面是下面给出的代码的截图。
Python remove a character from string translate method
通过索引从字符串 Python 中删除一个字符
- 在本节中，我们将学习如何通过索引从字符串 Python 中移除字符。
- 通过索引从字符串中删除一个字符我们可以很容易地使用 string by slicing 函数。
string Slicing()方法总是返回介于索引 a 和 b 之间的字符。从 a 开始，a+1，a+2……直到 b-1。
语法:
下面是字符串切片的语法。
String
[start:end:step_value]
让我们举一个例子来检查如何通过索引从字符串 Python 中删除一个字符。
str1 = "William"
print(str1[3:-2])
下面是下面给出的代码的截图。
Remove a character from a string python by index
从字符串中删除一个字符 python 熊猫
Pandas 是一个 python 模块，用于数据操作、分析和清理。Python pandas 模块或库非常适合不同的数据集，比如我们可以处理表格数据或序列。
- 在这个方法中，我们将学习和讨论如何从字符串 Python pandas 中删除一个字符。
- 首先，我们必须创建一个数据框，其中一列存储一个字符串。
- 然后，我们必须使用 str replace()方法，用另一个指定的字符指定一个字符。
语法:
下面是字符串切片的语法。
Column name
[
replace[
old_Str1,
new_Str2,
instance
]
]
让我们举一个例子来检查如何从字符串 Python Pandas 中删除一个字符。
import pandas as pd
dt = {'ALPHABET': ['a','z','f','h']
}
df = pd.DataFrame(dt, columns= ['ALPHABET'])
df['ALPHABET'] = df['ALPHABET'].str.replace('a','l')
print (df)
下面是下面给出的代码的截图。
Remove character from string python pandas
Python 从字符串中移除特殊字符
- 在这一节中，我们将学习如何在 Python 中从字符串中移除一个特殊字符。
- Python 使用多种方法从字符串中删除一个特殊字符，通过这些方法我们可以很容易地从字符串中删除一个字符。
- 以下是方法列表
- isalnum 页()
- 过滤器(str.isalnum，Str2)
Str.isalnum()方法总是返回一个布尔值，这意味着所有特殊字符都将从字符串中删除，并输出结果 true。如果字符串中有特殊字符，它将始终返回 False。
让我们举一个例子来检查如何使用 str 从字符串中删除一个特殊字符。 isalnum()方法。
str1 = "John! what's up#"
new_str2 = ''.join(char for char in str1 if char.isalnum())
print(new_str2)
下面是以下代码的截图
Remove a special character from string in python
filter(str.isalnum，Str2)函数也用于删除特殊字符。但是在这个函数中，我们没有在 str.isalnum，Str2 上使用 for 循环和 if 语句。我们将使用 filter()方法。
让我们举一个例子来检查如何使用 过滤器(str.isalnum，Str2) 从字符串中删除一个特殊字符
str2 = "John! what's up#"
new_str1 = ''.join(filter(str.isalnum,str2))
print(new_str1)
下面是以下代码的截图
Remove a special character from string in python using filter
上面的 Python 代码我们可以用来从字符串中删除一个特殊字符。
Python 从字符串列表中删除一个字符
- 在这一节中，我们将学习如何在 Python 中从列表的字符串中删除一个字符。
String replace()方法从字符串列表中替换一个字符。
语法:
以下是字符串替换的语法
replace[
old_Str1,
new_Str2,
]
让我们举一个例子来检查如何从列表中的字符串中删除一个字符
str2=['a','e','k','h']
str3="Micheal"
for i in str2:
str3=str3.replace(i,"")
print(str3)
下面是以下代码的截图
Remove a character from the string in the list
这是如何从 Python 列表中的字符串中删除字符。
阅读 Python 元组字典
Python 从字符串中移除一个字符的所有实例
- 在这一节中，我们将学习如何从 Python 中的字符串中删除一个字符的所有实例。
String replace()方法从字符串列表中替换一个字符。- 例如，要删除“California”中“a”的所有实例，我们必须使用字符串 replace()函数。
语法:
下面是字符串替换的语法。
replace[
old_Str2,
new_Str3,
instance
]
让我们举一个例子来检查如何从一个字符串中删除一个字符的所有实例。
str2="calfornia"
str3= str2.replace("a","")
print(str3)
下面是下面给出的代码的截图。
Remove all instances of a character from a string
这就是如何在 Python 中从一个字符串中删除一个字符的所有实例。
Python 从字符串正则表达式中删除一个字符
- 让我们看看如何在 Python 中使用 regex 从字符串中删除一个字符。在 Python 中，regex 代表一个正则表达式，它是一个字符序列，创建一个空间搜索模式来查找一个字符串。要在 Python 中使用 regex，我们可以使用‘re’模块。
- 在 Python 中，match 和 findall 方法用于搜索一个模式，它已经被导入到
re模块中。
例子:
让我们举一个例子，看看如何使用正则表达式从字符串中删除字符
假设你想从字符串中删除所有的‘o’字符，那么我们需要使用 sub() 函数来匹配给定字符串中的字符。在 Python 中，如果你想用空白字符替换字符串中的字符，那么使用 sub() 函数。
源代码:
import re
given_str = "Python is a good programmig language"
del_chr = r'o'
new_str = re.sub(del_chr, '', given_str)
print(new_str)
下面是以下给定代码的执行过程
Python remove a character from string regex
如何在 Python 中使用 regex 删除字符串中的多个字符
假设您想从字符串中删除所有的 'o '，' r '，' t' 字符，那么我们需要使用 sub() 函数来比较字符串中字符' o '，' r '，' t' 的所有情况。
源代码:
import re
str1 = "Micheal is a good boy"
new_cmp = r'[oit]'
out_str = re.sub(new_cmp, '', str1)
print(out_str)
在上面的代码中，我们将首先导入“re”模块，然后创建一个变量“str 1”，并用双引号将一个字符串赋值。现在我们需要在‘new _ CMP’变量中传递一个模式，它将比较给定字符串中的所有字符。
下面是以下给定代码的实现
Python remove a character from the string regex method
Python 从字符串开头移除字符
- 为了执行这个任务，我们可以使用不同的 Python 方法。第一种方法是使用
split()函数从字符串开头删除一个字符。 - 在 Python 中，
split()函数在指定的分隔符处将一个字符串分成一个列表。
举例:
让我们看看如何使用 split()函数从字符串中删除第一个字符
代码:
str1 = '!England!'
new_char = '!'
str2 = ''.join(str1.split(new_char, 1))
print(str2)
在这个例子中，我们使用了 join 和 split() 函数的组合来移除给定字符的第一个情况。
下面是以下代码的截图
Python remove a character from the string beginning
阅读 Python 字典弹出
使用 Slice()方法从字符串开头删除一个字符
为了解决这个问题，我们可以使用切片和连接方法的组合。在 Python 中， slice() 方法用于指定如何分割一个可迭代序列，而串联方法用于组合两个字符串。
源代码:
new_char = "Germany"
out_new_str = new_char[:0] + new_char[1:]
print ("Remove first character: ",out_new_str)
在上面的例子中，我们从索引 0 到 1 对对象‘new _ char’进行了切片，我们得到了类似‘ermany’的字符串，因为我们已经从字符串中移除了第一个开始字符。
下面是以下给定代码的输出
Python remove a character from the string beginning method
通过使用 join()和列表理解方法
在这种方法中，字符串中的每个字符都被转换成列表中的一个等价字符。为了删除这个特殊的字符，我们必须提到在 join() 函数中的索引号作为一个参数。
源代码:
new_str3 = "Oliva"
output = ''.join([new_str3[m] for m in range(len(new_str3)) if m != 0])
print ("Remove first character: ", output)
下面是以下给定代码的执行过程
Python remove a character from the string beginning
通过列表读取 Python 循环
Python 从字符串末尾移除字符
- 让我们看看如何在 Python 中从字符串中移除结束字符。
- 在这里，我们可以应用负索引方法来删除字符串的结束字符。通过使用切片，它从开始的索引到结尾提取字符串。
源代码:
student_nam = 'China'
out = student_nam[:-1]
print("remove last character:",out)
下面是以下给定代码的执行过程
Python remove a character from the string end
通过使用 split()函数删除最后一个字符
在这个例子中，我们使用了 join()和 split() 函数的组合来移除给定字符的最后一个情况，我们已经在代码中提到了要从字符串中移除哪个字符。
源代码:
giv_str = '!Japan'
new_char = 'n'
new_output = ''.join(giv_str.split(new_char, 1))
print(new_output)
下面是以下给定代码的输出
Python remove a character from string end split
通过使用 rstrip()方法
在 Python 中， rstrip() 方法帮助用户删除给定字符串右侧的字符。此方法返回字符串的副本，并删除字符串中的所有尾随字符。
语法:
下面是 rstrip()方法的语法
rstrip([chars])
举例:
让我们举一个例子，看看如何从字符串中删除结束字符
stu_str = 'Elite'
new_result = stu_str.rstrip(stu_str[-1])
print(new_result)
下面是以下给定代码的实现
Python remove a character from the string end
这就是如何在 Python 中从字符串中移除结束字符。
Python 删除字符串中存在的字符
这里我们可以看到字符是否存在于字符串中，它将从字符串中删除一个字符，否则它将显示'不存在'。
源代码:
new_str1 = "Micheal"
new_str2 = "gf"
if new_str1.find(new_str2) != -1:
print("Exist!")
else:
print("Not Exist!")
下面是以下给定代码的输出
Python remove a character from a string if exists
Python 从字符串中移除索引后的字符
- 这里我们可以看到如何在 Python 中从 index 之后的字符串中删除一个字符。
- 在这个例子中，我们已经指定了索引变量‘z’并分配了它们的编号。现在创建一个变量，并使用切片从字符串的特定索引处删除一个字符。
源代码:
new_char = "France"
z = 2
new_res = new_char[:z] + new_char[z+1:]
print(new_res)
下面是以下代码的截图
Python remove a character from the string after an index
从字符串 Python 中删除字母
在 Python 中要从字符串中删除一个字母，我们可以使用 Python string.replace()方法。这个方法将帮助用户用一个新字符替换一个字符，但是在这个例子中，我们必须用一个空字符串替换一个字符。
源代码:
str_name = input("Enter the name: ")
new_name = str_name.replace("o", "")
print("Remove letter from name: ",new_name)
如果您执行这段代码，它会要求您输入名称。replace()方法从字符串中删除‘o’字符，并显示没有‘o’字符的结果。
下面是以下给定代码的执行过程
Remove a letter from string Python
从字符串中删除多个字符 Python 熊猫
- 让我们看看如何使用 Python pandas 从一个字符串中删除多个字符。
- 为了完成这个任务，我们可以使用 dataframe 和 pandas 的概念从一个字符串中删除多个字符。
举例:
import pandas as pd
new_val = pd.DataFrame({'spcial_char':['/','@','&','*','%']})
rem_char= new_val['spcial_char'].str.replace('&','')
print (rem_char)
下面是以下给定代码的执行过程
Remove multiple characters from string Python Pandas
Python 剥离前两个字符
为了在 Python 中去掉字符串的前两个字符，我们可以应用切片方法的概念。在本例中， [2:] slice 表示从索引 2 开始，一直延续到结尾。
源代码:
str_new="This is my book"
b = str_new[2:]
print(b)
下面是以下给定代码的输出
Python strip first two characters
阅读 Python 字典理解
Python 剥离最后两个字符
- 这里我们可以看到如何在 Python 中去掉字符串的最后两个字符。
- 我们可以通过使用 list comprehension 和
list slicing()方法来实现。为了从字符串列表中删除最后两个字符，我们将首先初始化一个列表，然后创建一个变量‘rem _ las’，我们在其中传递了切片方法。
举例:
new_lis = ['Newzealand']
rem_las = [m[ : -2] for m in new_lis]
print("strip last two characters:",rem_las)
下面是以下给定代码的执行过程
Python strip last two characters
使用 strip()方法从字符串中删除最后两个字符
在 Python 中， strip() 函数从字符串的开头和结尾删除字符。如果你想删除字符串开头和结尾的空格，你可以使用 strip() 函数，它将返回相同的不带空格的字符串。
语法:
以下是给定代码的语法
"string".strip()
举例:
str2 = "John Appleseed**"
print(str2.strip('*'))
下面是以下给定代码的实现
Python strip last two characters using strip
将*从字符串 Python 中移除
在这里，我们可以使用 join 和 split() 函数的组合来从 Python 中的字符串中移除' * '。
源代码:
str_new= '*France*'
new_char = '*'
res_str = ''.join(str_new.split(new_char, 7))
print("Remove * from string:",res_str)
下面是以下给定代码的执行过程
remove from string python
您可能会喜欢以下 Python 教程:
在本教程中，我们学习了如何从字符串 Python 中移除字符。
- 如何在 Python 中从字符串中删除一个字符
- Python 使用 replace()方法从字符串中删除字符
- Python 使用 replace()方法从字符串中删除多个字符
- Python 使用 translate()方法从字符串中删除字符
- Python 使用 translate()方法从字符串中删除多个字符
- 从字符串 python 中移除第一个字符
- 从字符串 python 中删除 n 个字符
- 从字符串 python 中移除换行符
- 在 python 中移除指定次数
- Python 替换一个字符串中的多个字符
- 从字符串 python 中移除字符串
- 如何从字符串 python 中移除标点符号
- 移除字符串 python 中的最后一个字符
- 从字符串 python 中移除最后 4 个字符
- Python 删除了字符串中所有空格
- Python 只删除前导和尾随空格
- 在 python 中从一个字符串中删除多个字符
- 如何从字符串 python 中移除空格
- python 从字符串中剥离子字符串
- 通过索引从字符串 python 中移除字符
- 从字符串中删除一个字符 python 熊猫
- Python 从字符串中删除一个特殊字符
- Python 从列表中的字符串中删除一个字符
- Python 从字符串中删除一个字符的所有实例
- Python 从字符串正则表达式中删除字符
- Python 从字符串开头移除字符
- Python 从字符串末尾移除字符
- python 从字符串中移除字符(如果存在)
- Python 从索引后的字符串中删除字符
- 从字符串 Python 中移除字母
- 从字符串 Python pandas 中删除多个字符
- Python 剥离前两个字符
- Python strip 最后两个字符
- 从字符串 Python 中移除*
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中删除字符串的第一个字符
原文：https://pythonguides.com/remove-first-character-from-a-string-in-python/
在这个 Python 教程中，我们将讨论如何以不同的方式从 Python 中的字符串中移除第一个字符。考虑到 Python 字符串是不可变的，这意味着它不能被改变。
- 使用 python 中的切片方法移除字符串的第一个字符
- 使用 python 中的 replace 方法移除字符串的第一个字符
- 使用 python 中的 lstrip()方法移除字符串的第一个字符
- 使用 python 中的 translate 方法移除字符串的第一个字符
- 使用 python 中的 regex 方法移除字符串的第一个字符
- 使用 python 中的 split 函数移除字符串的第一个字符
- 使用 python 中的连接和列表理解方法移除字符串的第一个字符
- 如何从 Python 熊猫字符串中删除第一个字符
- 如何在 Python 中删除字符串的第一个 n 字符
- 如何移除列表中字符串的第一个字符
目录
- 使用 python 中的切片方法删除字符串的第一个字符
- 使用 python 中的 replace 方法删除字符串的第一个字符
- 使用 python 中的 lstrip()方法删除字符串的第一个字符
- 使用 python 中的 translate 方法删除字符串的第一个字符
- 使用 python 中的 regex 方法删除字符串的第一个字符
- 使用 python 中的 split 函数删除字符串的第一个字符
- 使用 python 中的连接和列表理解方法删除字符串的第一个字符
- 如何从 Python Pandas 字符串中删除第一个字符
- 如何在 Python 中删除字符串的第一个 n 字符
- 如何删除列表中字符串的第一个字符
使用 python 中的切片方法删除字符串的第一个字符
- 在这个例子中，我们将讨论如何使用切片方法在 Python 中删除字符串的第一个字符。
- 切片技术可用于从 Python 字符串中移除第一个字符，生成的字符串将没有第一个字符。通过使用切片 [1:] ，我们将获得除第一个字符之外的剩余字符串。
举例:
让我们举一个例子，看看如何使用切片方法从 Python 中删除字符串的第一个字符。
**# Input string**
Country_name = "United States of America"
print("Input string: ", Country_name)
**# By using the slicing method**
result = Country_name[1:]
print("First character has been removed from string: ", result)
在下面给出的代码中，我们将首先创建一个名为 country_name 的输入字符串，其中我们将字符串值赋给美利坚合众国(USA)。
现在我们要删除第一个字符‘U’，为此我们将使用 str[:1] 的概念，并获取除第一个字符之外的剩余字符串。
你可以参考下面的截图
How to remove the first character from a string in Python
这是如何使用切片方法从 Python 中删除字符串的第一个字符。
使用 python 中的 replace 方法删除字符串的第一个字符
- 在本节中，我们将了解如何使用
replace()方法从 Python 中删除字符串的第一个字符。 - 在 Python 中用新字符替换单个字符时，使用
replace()方法，这个方法将产生一个字符串的副本，用另一个子字符串替换一个子字符串的每个实例。 - 在这个例子中，如果我们想从字符串中删除第一个字符，那么我们必须提到第二个参数是一个空字符串。
语法:
让我们看一下语法并理解 Python 中的 str.replace() 方法的工作原理。
str.replace(old, new, count)
- 它由几个参数组成
old:-该参数定义了将要被替换的字符串。new:用新值(一个字符或字符串)替换现有值。count:-一个整数值，表示要用新字符或子串替换多少个旧字符或子串。这是一个可选参数。
举例:
这里我们将举一个例子，检查如何使用 replace() 方法从 Python 中删除字符串的第一个字符。
源代码 :-
**# Input string**
state_name_in_USA = 'Alaska'
**# Using replace() method**
result= state_name_in_USA.replace('A', '')
**# Display the content**
print(result)
在上面的例子中，我们使用了 str.replace() 函数，在这个函数中，我们提到了旧字符‘A’，并用一个新字符替换了它，但是在这种情况下，我们必须删除这个字符，所以第二个参数将是一个空字符串。
下面是以下给定代码的实现
How to remove the first character from a string in Python using replace
正如你在截图中看到的，我们已经讨论了如何使用 replace() 方法从 Python 中删除字符串的第一个字符。
使用 python 中的 lstrip()方法删除字符串的第一个字符
- 这里我们将了解如何使用
str.lstrip()方法在 Python 中移除字符串的第一个字符。 - 在移除作为输入提供的前导字符后，
lstrip()方法返回字符串的副本。如果没有给定参数，默认情况下会删除前导空格。
下面的示例代码展示了如何使用 str.lstrip() 方法删除字符串的开头字符。
源代码 :-
**# Input String**
Cars_in_USA = "Ford F-150, Chevrolet Silverado 1500"
print("Input string:",Cars_in_USA)
**# By using the lstrip()**
result = Cars_in_USA.lstrip("F")
**# Display the Content**
print("Remove first character:",result)
在下面给定的代码中，我们首先声明了一个变量‘Cars _ in _ USA’，然后分配美国最高的汽车。现在我们想要删除第一个字符，我们将使用 lstrip() 函数，在这个函数中，我们将第一个字符传递给它，我们想要从输入字符串中删除它。
下面是以下代码的截图
How to remove the first character from a string in Python using the lstrip() method
这就是我们如何使用 lstrip 方法从 Python 中删除字符串的第一个字符。
读取字符串中的 Python 查找数字
使用 python 中的 translate 方法删除字符串的第一个字符
- 在本节中，我们将了解如何使用
translate()方法从 Python 中删除字符串的第一个字符。 - Python 的
translate()函数用于返回一个字符串，字符串中的每个字符都被映射到翻译表中相应的位置。 - 要从结果字符串中删除一个字符，我们必须给出该字符的 Unicode 码位和单词“None”作为替换。为了确定字符的 Unicode 码位，我们可以利用
ord()方法。
语法:
下面是 Python 中 string.translate() 函数的语法。
string.translate(table)
注意:这个参数只接受一个参数，并定义一个转换表来存储两个字符之间的映射。
举例:
让我们举一个例子，看看如何使用 translate() 方法从 Python 中删除字符串的第一个字符
**# Input string**
cities_of_USA = 'New York, Los Angeles, California'
print("Original string:",cities_of_USA)
**# Using the translate() method**
result= cities_of_USA.translate({ord('N'): None})
print("First character removed:",result)
下面是以下给定代码的执行过程
How to remove the first character from a string in Python using the translate method
在这个例子中，我们已经了解了如何使用 translate 方法从 Python 中删除字符串的第一个字符。
使用 python 中的 regex 方法删除字符串的第一个字符
- 既然我们已经介绍了
slicing()和str.lstrip()方法，那么是时候看看 python 中的 regex()函数了。regex 模块的' re '类具有函数re sub()。也可以使用它来删除初始字符。 - Re.sub()用替换的值创建一个字符串，代表子串。当我们应用这个函数时，我们可以替换几个元素，它将替换所有匹配正则表达式的字符。
语法:
让我们看一下语法并理解 Python 中的re sub()方法的工作原理。
re.sub(pattern, repl, string, count=0, flags=0)
- 它由几个参数组成
- 模式:该参数定义了我们想要替换的字符串/模式。
repl:该参数用于定义替换花样的花样。Count:默认情况下，取值为 0，它定义了应该发生的替换次数。
举例:
这里我们将举一个例子，看看如何在 Python 中删除字符串的第一个字符。
源代码:
import re
**# input string**
Country_name = "U.S.A, Australia, Belgium"
**# By using the re.sub() method**
result = re.sub(r'.', '', Country_name, count = 1)
**# Display the content**
print(result)
因此，我们将首先导入 re 库来验证这个函数，它在 re 模块中，然后，我们生成一个字符串。
然后执行re()命令，并在其中传递参数字符串和计数。这里，我们利用表达式“计数= 1”来表示字符删除。
你可以参考下面的截图
How to remove the first character from a string in Python using the regex method
这就是我们如何使用 regex 方法从 Python 中删除字符串的第一个字符。
使用 python 中的 split 函数删除字符串的第一个字符
- 在这个例子中，我们将讨论如何使用
split()函数从 Python 中删除字符串的第一个字符。 - 这个函数用于在给定的字符串被指定的分隔符分割后，将字符串分割成子字符串。
- 此参数采用两个参数，并指定分隔符和最大拆分。它将在分割输入字符串后返回一个字符串列表。
举例:
Bikes_in_USA = 'Aprilia, Kawasaki, Ducati'
print("Input string:",Bikes_in_USA)
**#Using the split() function**
result= Bikes_in_USA.split("A")
print("First character remove from string:",result)
你可以参考下面的截图
How to remove the first character from a string in Python using the split function
这就是如何使用 split 函数从 Python 中删除字符串的第一个字符
使用 python 中的连接和列表理解方法删除字符串的第一个字符
- 在这一节中，我们将讨论如何使用 list comprehension 和
join()方法从 Python 中删除字符串的第一个字符。 - 使用 Python 中的
join()方法将一个字符串和一个 iterable 对象连接起来。它返回一个产品字符串，该字符串组合了 iterable 中的所有字符串。 - 通过使用 list comprehension 和 join 方法，我们可以很容易地将每个 string 元素拆分成相关的 list 元素，然后将它们连接起来以声明一个新的 string。
举例:
Country_name = "U.S.A, Germany, Australia"
print ("Input string: ", Country_name)
**# By using the join() method**
output = ''.join([Country_name [i] for i in range(len(Country_name )) if i != 0])
**# Display the Content**
print ("First character remove from string: ",output)
在下面给出的代码中，我们首先创建了一个名为“Country _ name”的输入字符串，并在其中指定了国家名称。接下来，我们使用了 join() 方法并用一个设定的条件迭代这些值，如果 i！=0 ，它将从字符串中删除第一个字符。
下面是以下给定代码的执行过程
How to remove the first character from a string in Python using the join method
正如你在截图中看到的，我们已经讨论了如何使用连接和列表理解方法从 Python 中删除字符串的第一个字符。
如何从 Python Pandas 字符串中删除第一个字符
- 这里我们将讨论如何在 Python Pandas 中删除字符串的第一个字符。
- 为了执行这个特定的任务，我们将使用切片方法。切片技术可用于从 Python 字符串中删除第一个字符，生成的字符串将没有第一个字符。通过使用切片 [1:] ，我们将获得除第一个字符之外的剩余字符串。
举例:
让我们举一个例子，看看如何在 Python Pandas 中删除字符串的第一个字符
import pandas as pd
df = pd.DataFrame({"Country_name":["U.S.A"]})
df
df["Country_name"].str[1:]
在上面的代码中，我们首先导入了 Pandas 库，然后使用 pd.dataframe() 创建了一个 dataframe，在这个函数中，我们指定了 country_name。接下来，我们使用切片方法，将从字符串中删除第一个字符。
你可以参考下面的截图
How to remove the first character from the string Python Pandas
这就是如何在 Python Pandas 中删除字符串的第一个字符。
如何在 Python 中删除字符串的第一个 n 字符
- 在这一节中，我们将讨论如何在 Python 中删除字符串的第一个 n 字符。
- 如果您想从字符串中删除前 n 个字符，那么从第
n个索引开始并在末尾结束对字符串进行切片。如果从第 n 个索引到末尾对字符串进行切片，则字符串的前 n 个字符将被删除，因为字符串中的字符是从零开始索引的。
举例:
下面是一个例子，我们将了解如何在 Python 中删除字符串的第一个 n 字符。
**# Input string**
Country_name = "United States of America"
print("Input string:",Country_name)
**# By using the slicing method**
result = Country_name[5:]
print("First character has been removed from string:",result)
在上面的代码中，我们设置 n=5，它将从输入字符串中删除前 5 个字符。
下面是以下给定代码的实现
How to remove the first n character from a string in Python
这是如何在 Python 中删除字符串的第一个 n 字符。
如何删除列表中字符串的第一个字符
- 在这个例子中，我们将了解如何从 Python 列表中的每个字符串中删除第一个字符。
- 在 Python 中用新字符替换单个字符时，使用
replace()方法，这个方法将产生一个字符串的副本，用另一个子字符串替换一个子字符串的每个实例。 - 在这个例子中，如果我们想删除列表中字符串的第一个字符，然后使用 for 循环方法迭代这些值。
示例:
这里我们将举一个例子，看看如何从 Python 列表中删除字符串的第一个字符。
cities_in_USA = ['New York', 'Los Angeles', 'Chicago', 'Houston']
**# Display original list**
print("Input list : ", cities_in_USA)
new_output = []
for m in cities_in_USA:
m=m.replace(m[0],"",1)
new_output.append(m)
**# Display the result**
print("First character has been removed from list :", new_output)
下面是以下代码的截图
How to remove the first character from each string in a list
这就是如何从列表中的每个字符串中删除第一个字符。
本文基于如何从 Python 字符串中删除第一个字符。已经提出了七种不同的方法，所有的方法都非常简单易懂。
- 使用 python 中的切片方法移除字符串的第一个字符
- 使用 python 中的 replace 方法移除字符串的第一个字符
- 使用 python 中的 lstrip()方法移除字符串的第一个字符
- 使用 python 中的 translate 方法移除字符串的第一个字符
- 使用 python 中的 regex 方法移除字符串的第一个字符
- 使用 python 中的 split 函数移除字符串的第一个字符
- 使用 python 中的连接和列表理解方法移除字符串的第一个字符
- 如何从 Python 熊猫字符串中删除第一个字符
- 如何在 Python 中删除字符串的第一个 n 字符
- 如何移除列表中字符串的第一个字符
您可能会喜欢以下 Python 教程:
- Python 从字符串中移除子串
- 如何在 Python 中将集合转换成列表
- Python 替换文件中的字符串
- Python 比较字符串
- Python 3 字符串方法及示例
- Python 在字符串中查找子串
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
移除非 ASCII 字符 Python
原文：https://pythonguides.com/remove-non-ascii-characters-python/
这篇 Python 教程讲的都是“去除非 ASCII 字符 Python ”。我们将会看到，如何用各种例子来删除 Python 中的非 ASCII 字符。
此外，我们将涵盖这些主题。
- 移除非 ASCII 字符 Python 熊猫
- 移除非 ASCII 字符 Python
- 移除非 ASCII 字符 Python 正则表达式
- 从 CSV Python 中移除非 ASCII 字符
- 从文件 Python 中移除非 ASCII 字符
- 去掉非 ASCII 字符 Python
- Pyspark 替换非 ASCII 字符 Python
- 从文本 Python 中移除非 ASCII 字符
- Python 从字节中删除了非 ASCII 字符
ASCII 代表美国信息交换标准码。美国键盘上的所有关键字都有一些 ASCII 码。非 ASCII 码大多出现在不同国家的地区语言中。
例如，中文、日文、印度文等属于非 ASCII 字符。在本教程中，我们将学习如何删除 python 中的非 ASCII 字符。
您可能想知道非 ASCII 字符是什么样子的。这是非 ASCII 字符的例子。
¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇËÎÐÖÑ×Øψϑωϖℵℜ←↑→↓↔↵⇐⇑⇒⇓⇔∀
目录
- 删除非 ASCII 字符 Python 熊猫
- 删除非 ASCII 字符 Python
- 删除非 ASCII 字符 Python Regex
- 从 CSV Python 中删除非 ASCII 字符
- 剥离非 ASCII 字符 Python
- 如何剥离 Python 中的非 ASCII 字符
- Pyspark 替换非 ASCII 字符 Python
- 从文本 Python 中删除非 ASCII 字符
- Python 从字节中删除非 ASCII 字符
删除非 ASCII 字符 Python 熊猫
- 在这一节中，我们将学习如何删除 Python pandas 中的非 ASCII 字符。
- 通过使用编码和解码功能，我们可以很容易地从 Pandas 数据帧中移除非 ASCII 字符。在 Python 中，
encode()函数用于使用给定的编码对字符串进行编码，解码意味着将一串字节转换成 Unicode 字符串。
源代码:
import pandas as pd
df = pd.Series(['m©ª«zy', '¤¥uw', 'ÆÇval 672'])
d= df.str.encode('ascii', 'ignore').str.decode('ascii')
print("After removing non-ascii:")
print(d)
在上面的代码中，我们首先导入了 Pandas 库，然后创建了一个数据帧，在其中我们分配了一些字符和非 ASCII 字符。
现在应用 encode() 函数，它将帮助用户将字符串编码成‘ASCII’，还将错误作为‘忽略’传递，以移除非 ASCII 字符。
下面是以下给定代码的执行过程
Remove Non-ASCII Characters Python Pandas
删除非 ASCII 字符 Python
- 在本期节目中，我们将讨论如何去除 Python 3 中的非 ASCII 字符。
- 这里我们可以应用方法
str.encode()从字符串中删除非 ASCII 字符。要执行这项任务，首先创建一个简单的字符串，并在其中分配多个字符，就像非 ASCII 字符一样。现在，首先我们将应用 encode()方法将字符串编码为 ASCII，然后使用 decode()方法帮助用户将字节字符串转换为新字符串。
举例:
new_str = "¡¢£ Py¼½¾thon is a be¹ºst prog®¯°ramming language±²³."
print("Original string:",new_str)
new_val = new_str.encode("ascii", "ignore")
updated_str = new_val.decode()
print("After romoving non-ascii:")
print(updated_str)
你可以参考下面的截图
Remove Non-ASCII Characters Python
删除非 ASCII 字符 Python Regex
- 让我们看看如何在 Python Regex 中移除非 ASCII 字符。
- 在这个程序中，我们将看到如何使用正则表达式从字符串中删除非 ASCII 字符。在 Python 中，正则表达式可用于在字符串中搜索模式。在 Python 中， 're' 模块提供了在程序中使用正则表达式的支持。
源代码:
import re
String_value='JoÂÃÄÅhn i×Øψs a goωϖℵod b¡¢oy'
print("Original string:",String_value)
new_result = re.sub(r'[^\x00-\x7f]', "", String_value)
print("After removing ASC-II charcater from string : ")
print(new_result)
在上面的代码中，我们先导入 re 模块，然后在名为 'String_value' 的变量中创建一个字符串。
现在我们将使用函数re sub()从字符串中删除非 ASCII 字符，并将结果存储在输出变量‘new _ result’中。
一旦打印了' new_result' ,输出将显示更新后的字符串。
下面是以下给定代码的输出
Remove Non-ASCII Characters Python Regex
从 CSV Python 中删除非 ASCII 字符
- 在这一节中，我们将学习如何在 Python 中从 CSV 文件中移除非 ASCII 字符。
- 这里我们可以看到如何删除 CSV 文件中的非 ASCII 字符。为了完成这个任务，我们将应用 Pandas 方法，并在数据帧中使用
encode()方法。
源代码:
import pandas as pd
data = pd.read_csv('test1.csv', encoding= 'unicode_escape')
new_val = data.encode("ascii", "ignore")
updated_str = new_val.decode()
print("After romoving non-ascii:")
print(updated_str)
Remove Non-ASCII Characters From CSV Python
正如您在屏幕截图中看到的，作为特定非 ASCII 字符的输出没有从 CSV 文件中删除，因为数据帧没有属性，并且在 CSV 文件模式下不会更新。
剥离非 ASCII 字符 Python
- 这里我们可以看到如何在 Python 中去除 ASCII 字符。
- 在这个例子中，我们将使用. sub()方法，在这个方法中，我们分配了一个标准代码 '[^\x00-\x7f]' ，这个代码表示 0-127 ASCII 码之间的值，这个方法包含输入字符串‘new _ str’。一旦您将打印‘new _ result’，那么输出将显示新的字符串，并且其中不包含任何非 ASCII 字符。
源代码:
import re
new_str='Australia©ª«Germany'
new_result = re.sub(r'[^\x00-\x7f]', "", new_str)
print(new_result)
下面是以下给定代码的输出
Strip Out Non-ASCII Characters Python
如何剥离 Python 中的非 ASCII 字符
在这个程序中，我们将结合使用 ord()和 for 循环方法来删除字符串中的非 ASCII 字符。
在 Python 中， ord() 方法只接受单个字符，这个方法将帮助用户检查一个字符串是否包含单个 Unicode 字符。
举例:
new_val = "Mi©ª«chal is a³´µ¶·good b½¾¿oy"
new_res = ''.join([m if ord(m) < 128 else ' ' for m in new_val])
print("After strip ascii characters: ",new_res)
在上面的代码中，我们首先创建了一个字符串‘new _ val’，并为它们分配了非 ASCII 字符。
现在我们将在 ord()方法中使用 join() 函数。正如您在下面的屏幕截图中看到的，非 ASCII 字符从新字符串中删除后的输出。
你可以参考下面的截图
Strip Out Non-ASCII Characters Python
Pyspark 替换非 ASCII 字符 Python
- 在本节中，我们将学习如何在 pyspark python 中替换非 ASCII 字符。
- 在 Python 中，如果您想使用 Apache Spark 运行应用程序，那么我们将应用 Pyspark 库，例如，如果您正在使用 Python 应用程序处理大数据集，那么 Pyspark 是解决这个问题的最佳方式，它比 Pandas 库更快。
- 在本例中，我们导入了 Pyspark 模块，首先使用 pyspark.row 库来表示 DataFrame 中的一行数据。现在，我们将使用 spark 上下文和 spark 会话来创建数据帧。
源代码:
from pyspark.sql import Row
from pyspark.context import SparkContext
from pyspark.sql.session import SparkSession
sc = SparkContext('local')
spark = SparkSession(sc)
df = spark.createDataFrame([
(0, "Pyt¾¿hon Deve¾¿loper"),
(1, "Jav±²³a Deve±²³loper"),
(2, "S£¤¥ql Datab£¤¥ase"),
(3, "Mongodb database")
], ["id", "words"])
from pyspark.sql.functions import udf
def ascii_ignore(x):
return x.encode('ascii', 'ignore').decode('ascii')
ascii_udf = udf(ascii_ignore)
df.withColumn("foo", ascii_udf('words')).show()
在上面的代码中，我们首先使用 spark.createDataFrame 创建了一个 Dataframe 对象，并在其中分配了非 ASCII 字符。
现在使用 UDF (用户自定义函数)，它用于在 Spark 中创建一个可重用的方法。
下面是以下给定代码的执行过程
Pyspark Replace Non-ASCII Characters Python
阅读如何用 Python 将 Pandas 数据帧转换成 NumPy 数组
从文本 Python 中删除非 ASCII 字符
- 在这一节中，我们将学习如何用 Python 从文本中删除非 ASCII 字符。
- 这里我们可以使用
replace()方法从字符串中删除非 ASCII 字符。在 Python 中，str.replace()是一个内置函数，这个方法将帮助用户用新的或空的字符串替换旧的字符。
源代码:
new_ele = "England Germanyℜ←↑→China"
new_result = new_ele.replace('ℜ←↑→', '')
print("Removing ascii characters from text : ",new_result)
在上面的代码中，我们首先创建了一个字符串“new_ele ”,然后使用 str.replace() 方法用空格替换特定的非 ASCII 字符。
一旦您打印了‘new _ result’，那么输出将显示删除了所有非 ASCII 字符的新字符串。
下面是以下给定代码的实现
Remove Non-ASCII Characters from Text Python
Python 从字节中删除非 ASCII 字符
- 在这一节中，我们将学习如何在 Python 中从字节中删除非 ASCII 字符。
- 让我们看看如何在
encode()函数中使用字节码从字符串中删除非 ASCII 字符。
源代码:
import re
new_str='Oliva→↓↔↵⇐Elijah'
re.sub(r'[^\x00-\x7f]',r' ',new_str)
m = new_str.encode('utf8')
z=re.sub(rb'[^\x00-\x7f]',rb' ',m)
print(z)
下面是以下代码的截图
Python Remove Non-ASCII Characters From Bytes
您可能会喜欢以下 Python 教程:
- Python 中的乘法与例题
- 删除 Python 中字符串的第一个字符
- Python 中的字符串索引超出范围
- Python 查找列表中元素的索引
- 使用 python 从 URL 下载 zip 文件
- Python 对于基数为 10 的 int()无效文字
- 删除 python 中的 Unicode 字符
- Python 中的注释行
在本教程中，我们学习了如何在 python 中移除非 ASCII 字符。此外，我们已经讨论了这些主题。
- 移除非 ASCII 字符 Python 熊猫
- 移除非 ASCII 字符 Python
- 移除非 ASCII 字符 Python 正则表达式
- 从 CSV Python 中移除非 ASCII 字符
- 从文件 Python 中移除非 ASCII 字符
- 去掉非 ASCII 字符 Python
- Pyspark 替换非 ASCII 字符 Python
- 从文本 Python 中移除非 ASCII 字符
- Python 从字节中删除了非 ASCII 字符
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
在 Python 中从字符串中移除特定字符
原文：https://pythonguides.com/remove-specific-character-from-string-in-python/
在本 Python 教程中，我们将讨论如何以不同的方式从 Python 中的字符串中移除特定字符。Python 有内置函数，允许您删除字符串中的每个特殊字符。以下是我们将要讨论的话题。
- 如何使用
isalpha()函数在 Python 中删除字符串中的特定字符 - 如何在 Python 中使用正则表达式方法从字符串中移除特定字符
- 如何使用 isdecimal()函数在 Python 中删除字符串中的特定字符
- 如何使用 translate 函数在 Python 中移除字符串中的特定字符
- 如何使用 filter()方法在 Python 中移除字符串中的特定字符
- 如何使用连接和列表理解方法在 Python 中删除字符串中的特定字符
目录
- 在 Python 中使用 isalpha()函数从字符串中删除特定字符
- 使用 Python 中的正则表达式从字符串中删除特定字符
- 如何使用 isdecimal() 在 Python 中移除字符串中的特定字符
- 使用 translate() 在 Python 中删除字符串中的特定字符
- 如何使用 filter()方法在 Python 中删除字符串中的特定字符
- 使用连接和列表理解方法从 Python 中的字符串中删除特定字符
在 Python 中使用 isalpha()函数从字符串中删除特定字符
- 如果字符串中的所有字符都是字母或数字，
string.isalnum()方法返回 True 否则，它返回 False。 isalnum()如果字符串包含一个或多个与以下任何组都不匹配的字符，则返回 False。- 现在，在这个例子中，我们可以很容易地使用
isalnum()函数来删除 Python 中一个字符串的所有特定字符。
语法:
让我们看一下语法，理解如何在 Python 中从字符串中删除特定的字符。
str.isalnum()
注意:这个函数不包含任何参数，它总是返回 false 或 true。
举例:
让我们举一个例子，看看如何通过使用 str.isalnum() 方法从 Python 中删除字符串中的特定字符。
**#Input string**
Country_name = "Unit$ed S@tates o!f Amer^ica"
**# By using the str.isalpha() function**
result="".join(m for m in Country_name if m.isalpha())
**# Display the new string**
print (result)
在上面的例子中，列表中的所有条目都被连接起来，生成一个字符串。加入”功能。这里我们使用输入字符串作为国家名称“Unit$ed S@tates o！f Amer^ica”，现在想要删除输入字符串中所有可用的特定字符。
为此，我们使用了 m.isalpha() 函数，它将从字符串中删除所有特定的字符。
下面是以下给定代码的实现
How to remove a specific character from a string by using the isalpha function
这就是我们如何使用 isalpha 函数从字符串中删除特定的字符。
使用 Python 中的正则表达式从字符串中删除特定字符
- 为了创建可用于搜索字符串中特殊字符的模式，使用了正则表达式。Python 要求在使用正则表达式之前导入重新打包。
- 在 Python 中从字符串中移除特殊字符时，会使用该属性。重新打包后，我们可以通过多种方式使用正则表达式。Python 的
re sub()方法可以用来消除字符串中的特殊字符。 - 当我们应用这个函数时，我们可以替换特定的元素，它将替换所有匹配正则表达式的字符。
语法:
让我们看一下语法并理解 Python 中的re sub()方法的工作原理。
re.sub(pattern, repl, string, count=0, flags=0)
- 它由几个参数组成
- 模式:该参数定义了我们想要替换的字符串/模式。
repl:该参数用于定义替换花样的花样。Count:默认情况下，它取一个0值，它定义了应该发生的替换次数。
举例:
让我们举一个例子，看看如何使用 re.sub() 函数从 Python 字符串中删除特殊字符
import re
**# string with special characters**
Country_name = "U.S.A, Au@st#ralia, Be%lg*iu!m"
print("Input string with specific characters : ",Country_name)
**#By using the re.sub() method** result =re.sub("[@,#,%,!,*]", "", Country_name,count=0)
print("Input string after removing the special characters : ",result)
因此，我们将首先导入 re 库来验证 re 模块中的函数，然后，我们生成一个字符串，输入字符串是 Country_name，在该字符串中我们将国家名称分配给它" U . s . a，Au@st#ralia，Be%lg*iu！m" 。
现在我们想从字符串中删除特殊字符，为此我们将在re sub()函数中创建一个特殊字符列表。
然后执行re()命令，并在其中传递参数字符串和计数。这里，我们利用表达式“计数= 1”来表示字符删除。
下面是以下给定代码的实现。
How to remove a specific character from a string by using the regular expression method
正如你在截图中看到的，我们已经讨论了如何使用正则表达式方法从字符串中删除特定的字符。
如何使用 isdecimal() 在 Python 中移除字符串中的特定字符
- 在本节中，我们将讨论如何使用
isdecimal()函数从字符串中删除特定字符。 - 如果字符串中的每个字符都是十进制字符，则
isdecimal()方法返回 True。如果不是，则返回 False。十进制字符是那些基数为10的字符。
语法:
下面是 Python 中 isdecimal() 函数的语法
isdecimal()
注意:这个函数不包含任何参数，它总是返回 false 或 true。
举例:
让我们举一个例子，看看如何使用 isdecimal() 函数从字符串中删除特定的字符。
源代码:
**# input string**
new_string ="4@1$#4%5^"
**# By using the str.isdecimal() function**
new_output="".join(i for i in new_string if i.isdecimal())
**# Display the new_string**
print ("Special characters removed from strings:",new_output)
在下面给出的代码中，我们首先导入输入字符串，然后使用 str.isdecimal() 函数。它遍历字符串，确定每个字符是否是数字，如果是，则返回该字符。
你可以参考下面的截图。
How to remove a specific character from a string by using the isdecimal function
这是如何使用 Python 中的 isdecimal 函数从字符串中删除特定字符。
阅读: Python 对于基数为 10 的 int()无效文字
使用 translate() 在 Python 中删除字符串中的特定字符
- 在这里，我们将了解如何使用 Python 中的 translate 函数从字符串中删除特定字符。
- 要从结果字符串中删除一个字符，我们必须给出该字符的 Unicode 码位和单词“None”作为替换。为了确定字符的 Unicode 码位，我们可以利用
ord()方法。
语法:
下面是 Python 中 string.translate() 函数的语法。
string.translate(table)
注意:该参数只取一个参数，定义一个存储两个字符之间映射的翻译表。
举例:
让我们举一个例子，看看如何使用 translate() 方法从 Python 中删除字符串中的特定字符
import string as st
**# Input string**
cities_of_USA = 'New@York, Los#Angeles, Cal$ifornia, Hou*ston, San&Jose'
**# Creating list of special characters**
list_of_specific_char=['@','#','$','*','&']
**# Display the input**
print("Input string : ",cities_of_USA )
new_trans = {special_char: '' for special_char in st.punctuation}
**# By using the maketrans()**
result = str.maketrans(new_trans)
new_str = cities_of_USA .translate(result)
print("Specific characters removed from string : ",new_str)
在上面的例子中，我们创建了一个名为 'cities_of_USA' 的输入字符串，在这个字符串中，我们指定了位于美国的城市名称。
现在我们必须从字符串中删除特殊字符，为此，我们使用了事务和标点()函数。
包含所有特殊字符的字符串称为 string .标点() 。利用这一点，生成一个以特殊字符为键，以空值为值的字典。
下面是以下给定代码的实现
How to remove a specific character from a string by using the translate function
在这个例子中，我们已经了解了如何使用 translate 函数从字符串中删除特定的字符。
阅读: Python 检查变量是否为整数
如何使用 filter()方法在 Python 中删除字符串中的特定字符
- 在本节中，我们将讨论如何使用 Python 中的
filter()方法从字符串中删除特定字符。 str.isalpha方法将被filter()函数应用于字符串中的每一个元素，如果返回 True，将返回该元素。如果不是，它将忽略该项目。- 在过滤器()返回一个包含字符串中所有字母的迭代器后，join () 函数将用一个空字符串连接迭代器中的所有元素。
举例:
让我们举一个例子，看看如何使用 filter() 方法从字符串中删除特定的字符
**# Input string**
Bikes_in_USA = 'Ap@ril#ia, Ka$was%aki, Du&ca!ti'
**# By using the filter and isalpha() method**
new_var=filter(str.isalpha,Bikes_in_USA)
result="".join(new_var)
print ("Remove specific characters from string :",result)
在下面的代码中，我们首先创建了输入字符串 Bikes_in_USA = 'Ap@ril#ia，Ka$was%aki，Du & ca！然后使用了过滤器()函数，在这个函数中，我们传递了 str.isalpha 作为参数。
你可以参考下面的截图
How to remove a specific character from a string by using the filter method
这就是我们如何使用 Python 中的 filter 方法从字符串中删除特定字符。
读取:检查一个数字是否是质数
使用连接和列表理解方法从 Python 中的字符串中删除特定字符
- 在这个例子中，我们将讨论如何通过使用 python 中的连接和列表理解方法从 Python 中的字符串中删除特定字符。
- 通过使用 list comprehension 和 join 方法，我们可以很容易地将每个 string 元素拆分成相关的 list 元素，然后将它们连接起来以声明一个新的 string。
举例:
让我们举一个例子，看看如何使用 python 中的连接和列表理解方法从字符串中删除特定的字符。
源代码:
**# Input String**
Cars_in_USA = "Te@sla, Toyota, Ford"
print("Input string:",Cars_in_USA)
**# By using the join() method**
output = ''.join([Cars_in_USA [i] for i in range(len(Cars_in_USA )) if i != 2])
**# Display the Content **
print ("First character remove from string: ",output)
下面是以下给定代码的实现
How to remove a specific character from a string by using the join and list comprehension method in python
另外，看看更多的 Python 教程。
- python 中的百分号是什么意思
- Python 中如何在数字前加零
- 如何在 Python 中从列表中找到一个字符串
- Python 内置函数示例
- Python 语法错误:函数外的“return”
- 二分搜索法的 Python 程序
在本文中，我们已经讨论了如何以不同的方式从 Python 的字符串中删除特定的字符。我们还介绍了一些不同的方法，允许你从字符串中删除每个特殊字符。
- 如何使用
isalpha()函数在 Python 中删除字符串中的特定字符 - 如何在 Python 中使用正则表达式方法从字符串中移除特定字符
- 如何使用 isdecimal()函数在 Python 中删除字符串中的特定字符
- 如何使用 translate 函数在 Python 中移除字符串中的特定字符
- 如何使用 filter()方法在 Python 中移除字符串中的特定字符
- 如何使用连接和列表理解方法在 Python 中删除字符串中的特定字符
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
如何在 Python 中删除字符串的最后一个字符
原文：https://pythonguides.com/remove-the-last-character-from-a-string-in-python/
在本 Python 教程中，我们将讨论如何在 Python 中移除一个字符串的最后一个字符。此外，我们将演示七种有趣的技术来删除 Python 中字符串的最后一个字符。
- 如何在 Python 中删除字符串的最后一个字符
- 如何使用切片方法从 Python 中移除字符串的最后一个字符
- 如何使用 translate 方法在 Python 中移除字符串的最后一个字符
- 如何使用 rstrip 方法在 Python 中移除字符串的最后一个字符
- 如何使用 regex 方法从 Python 中删除字符串的最后一个字符
- 如何使用 for 循环概念在 Python 中删除字符串的最后一个字符
- 如何使用连接和列表理解方法在 Python 中删除字符串的最后一个字符
- 如何使用 replace()方法在 Python 中移除字符串的最后一个字符
- 如何从字符串 Python NumPy 中删除最后一个字符
目录
- 如何使用切片方法从 Python 中删除字符串的最后一个字符
- 如何使用 translate 方法删除 Python 中字符串的最后一个字符
- 如何使用 rstrip 方法从 Python 中删除字符串的最后一个字符
- 如何使用 regex 方法删除 Python 中字符串的最后一个字符
- 如何使用 for 循环概念从 Python 中删除字符串的最后一个字符
- 如何使用连接和列表理解方法从 Python 中删除字符串的最后一个字符
- 如何使用 replace()方法从 Python 中删除字符串的最后一个字符
- 如何删除字符串 Python NumPy 的最后一个字符
如何使用切片方法从 Python 中删除字符串的最后一个字符
- 在这里，我们将尝试理解如何使用切片方法从 Python 中删除字符串的最后一个字符。
- 字符串切片是一种从字符串中删除最后一个字符的 Python 技术。您可以通过使用字符串切片函数获得一个子字符串。为了从字符串中提取某些字符，使用了索引。
- 在这个例子中，我们将通过切片使用负索引来删除字符串中的最后一个字符。
语法:
str[:-1]
举例:
让我们看一个例子来帮助你更好地理解这个概念。
**# Input string**
Country_name = " The United States of America"
print("Input string: ", Country_name)
**# By using the slicing negative index**
result = Country_name[:-1]
**# Display the Content**
print("Last character has been removed from string: ", result)
这里我们取了一个输入字符串Country _ name = " United States of America "，然后为了删除字符串中的最后一个字符，索引从 -1 开始。
我们通过在-1 索引处对字符串进行切片，删除了它的最后一个字符。最后，结果已经打印出来。因此，我们可以看到最后一个字符已被删除。
你可以参考下面的截图。
How to remove the last character from a string in Python by using the slicing method
如何使用 translate 方法删除 Python 中字符串的最后一个字符
- 在这个例子中，我们将讨论如何使用 translate 方法从 Python 字符串中删除最后一个字符。
- Python 的
translate()函数用于返回一个字符串，字符串中的每个字符都被映射到翻译表中相应的位置。 - 要从结果字符串中删除一个字符，我们必须给出该字符的 Unicode 码位和单词“None”作为替换。为了确定字符的 Unicode 码位，我们可以利用
ord()方法。
举例:
**# Input string**
cities_of_USA = 'New York, Los Angeles, California'
print("Input string:",cities_of_USA)
**# Using the translate() method**
new_output= cities_of_USA.translate({ord('a'): None})
**# Display the Content**
print("Last character removed: ", new_output)
下面是以下给定代码的实现
How to remove the last character from a string in Python by using the translate method
在这个例子中，我们讨论了如何使用 translate 方法从 Python 中删除字符串的最后一个字符。
阅读:如何在 Python 中使用 For 循环对列表中的元素求和
如何使用 rstrip 方法从 Python 中删除字符串的最后一个字符
- 使用字符串函数 rstrip 移除给定字符串右侧的字符。因此，我们将使用它来删除字符串的最后一个字符。
- 方法从提供的后续字符中去掉字符串的最后几个字符。如果没有提供参数，它将删除末尾的空格。
语法:
让我们看一下语法并理解 Python 中的rst rip()方法的工作原理。
string.rstrip(chars)
注意:它只有一个参数，表示要删除的尾部字符。
示例:
new_val = input("Enter the Country name : ")
new_output = new_val.rstrip(new_val[-1])
print("Last character removed from String : ",new_output)
你可以参考下面的截图
How to remove the last character from a string in Python by using the rstrip method
这是如何使用 rstrip 方法从 Python 中移除字符串的最后一个字符。
如何使用 regex 方法删除 Python 中字符串的最后一个字符
- Regex()是一个 Python 函数，可用于匹配字符串中的两个组。regex 模块的' re '类具有函数
re sub()。最后一个字符也可以用它来删除。 - Re.sub()是 Python regex 提供的一种方法，用于搜索和替换字符串中的模式。通过使用这种技术，我们可以用不同的字符串替换目标字符串中的一个或多个正则表达式模式实例。
语法:
让我们看一下语法并理解 Python 中的re sub()方法的工作原理。
re.sub(pattern, repl, string, count=0, flags=0)
- 它由几个参数组成
- 模式:该参数定义了我们想要替换的字符串/模式。
repl:该参数用于定义替换花样的花样。Count:默认情况下，取值为 0，它定义了应该发生的替换次数。
举例:
为了更好地理解这个想法，让我们看一个例子。
源代码:
import re
# input string
Country_name = "U.S.A, France, Belgium"
# By using the re.sub() method
new_output = re.sub(r'm', '', Country_name, count = 1)
# Display the content
print("Removed last character from input string: ",new_output)
因此，我们将首先导入 re 库来验证这个函数，它在 re 模块中，然后，我们生成一个字符串。
然后执行re()命令，并在其中传递参数字符串和计数。这里，我们利用表达式“count = 1”来表示字符删除，在这个函数中，我们传递了想要从输入字符串中删除的字母。
下面是以下给定代码的实现。
How to remove the last character from a string in Python by using the regex method
正如你在截图中看到的，我们已经讨论了如何使用 regex 方法从 Python 中删除字符串的最后一个字符。
如何使用 for 循环概念从 Python 中删除字符串的最后一个字符
- 字符串中的最后一个字符也可以使用 for 循环删除。函数
len()将用于提取字符串的长度。 - 接下来，将生成一个空字符串。之后，我们将通过从 0 到 l-2 的循环迭代将字符串追加到空字符串。
- 输出将作为最终的字符串打印出来。
举例:
让我们举一个例子，看看如何在 Python 中删除字符串的最后一个字符。
源代码:
# Input string
Companies_in_USA = "Walmart, Amazon, Apple"
print("Input string: ",Companies_in_USA )
# Calculate string length
new_length = len(Companies_in_USA)
#empty string
new_string = ""
# By using for-loop
for i in range(0,new_length-1):
new_string = new_string + Companies_in_USA[i]
print("Remove last Character : ",new_string)
在本例中，我们首先获取输入字符串Companies _ in _ USA=“Walmart，Amazon，Apple ”,然后我们使用 len()函数来确定字符串的长度。
为了创建新的字符串，我们采用了一个空字符串，并将其附加到现有的字符串。接下来，我们将空字符串中的字符添加到 for 循环的每次迭代中，我们使用它从索引 0 到 new_length-1 。
我们最终打印出了创建好的字符串，它将显示从输入字符串中删除的最后一个字符。
下面是以下给定代码的实现。
How to remove the last character from a string in Python by using the for loop concept
这是如何使用 for 循环概念从 Python 中删除字符串的最后一个字符。
阅读: Python 程序求偶或奇
如何使用连接和列表理解方法从 Python 中删除字符串的最后一个字符
- 这里我们将讨论如何通过使用 python 中的连接和列表理解方法来删除 Python 中字符串的最后一个字符。
- 通过使用 list comprehension 和 join 方法，我们可以很容易地将每个 string 元素拆分成相关的 list 元素，然后将它们连接起来以声明一个新的 string。
举例:
这里我们将举一个例子，检查如何通过使用 python 中的****连接和列表理解方法从 Python 中删除字符串的最后一个字符。
****源代码**:
# Input string
state_name_in_USA = 'Alaska'
print ("Original string: ", state_name_in_USA)
# By using the join() method
new_result = ''.join([state_name_in_USA [m] for m in range(len(state_name_in_USA )) if m != 5])
# Display the Content
print ("Last character remove from string: ",new_result)
在下面给出的代码中，我们首先创建了一个名为“state _ name _ in _ USA”的输入字符串，并在其中为其指定了州名。接下来，我们使用了 join() 方法并用一个设定的条件迭代这些值，如果 i！=5 ，它将删除字符串中的最后一个字符。
下面是以下代码的截图
How to remove the last character from a string in Python by using the join and list comprehension method in python
正如你在截图中看到的，我们已经讨论了如何使用连接和列表理解方法从 Python 中删除字符串的最后一个字符。
阅读:Python 中的复数
如何使用 replace()方法从 Python 中删除字符串的最后一个字符
- 在这个例子中，我们将了解如何通过使用 Python 中的
replace()方法来删除 Python 中字符串的最后一个字符。 - Python 中一个名为
replace()的内置函数通过用一个子字符串替换另一个子字符串来创建一个新字符串。 - 在本例中，如果我们想从输入字符串中删除最后一个字符，那么我们必须提供第二个参数作为空字符串“”。
语法:
让我们看一下语法并理解 Python 中的 str.replace() 方法的工作原理。
str.replace(old, new, count)
- 它由几个参数组成
old:-该参数定义了将要被替换的字符串。new:用新值(一个字符或字符串)替换现有值。count:-一个整数值，表示要用新字符或子串替换多少个旧字符或子串。这是一个可选参数。
举例:
# Input string
Cars_in_USA = 'Tesla, BMW'
# By Using replace() method
new_output= Cars_in_USA.replace('W', '')
# Display the content
print("Last character has been removed from string: ",new_output)
在下面给定的代码中，我们使用了 str.replace() 函数，在这个方法中，我们提供了旧字符‘W’，并用一个新字符替换了它，但是在这种情况下，我们必须删除这个字符，所以第二个参数将是一个空字符串。
你可以参考下面的截图
How to remove the last character from a string in Python by using the replace method in Python
在这个例子中，我们已经了解了如何通过使用 Python 中的 replace 方法来删除 Python 中字符串的最后一个字符。
阅读: Python 回文程序
如何删除字符串 Python NumPy 的最后一个字符
- 在这一节中，我们将讨论如何在 NumPy Python 中删除字符串的最后一个字符。
- 为了执行这个特定的任务，我们将使用
numpy.char.replace()函数。在每个实例中，旧的子串被新的子串替换后，replace()函数返回一个字符串或字符串数组的副本。 - 当您想要用新的字符串值替换数组元素中的子字符串时，这个函数非常有用。
语法:
下面是 Python 中 numpy.char.replace() 函数的语法
numpy.char.replace(a, old, new, count=None)
- 它由几个参数组成
a:这个参数定义了我们插入字符串元素的输入数组。old:要替换的原始子串由该参数指定。new:该参数定义用来替换旧子串的新子串。
举例:
import numpy as np
# Creation of input array
Country_name = np.array([" The United States of America"])
# Create old character
old = "a"
# creating a new character
new = " "
# By using the char.replace() function
new_result = np.char.replace(Country_name, old, new)
print("last character removed from array: ",new_result)
下面是以下代码的截图
How to remove the last character from the string Python NumPy
您可能也喜欢阅读以下 Python 教程。
在本教程中，我们讨论了如何在 Python 中删除一个字符串的最后一个字符，我们还应用了不同的技术来删除 Python 中一个字符串的最后一个字符。
- 如何在 Python 中删除字符串的最后一个字符
- 如何使用切片方法从 Python 中移除字符串的最后一个字符
- 如何使用 translate 方法在 Python 中移除字符串的最后一个字符
- 如何使用 rstrip 方法在 Python 中移除字符串的最后一个字符
- 如何使用 regex 方法从 Python 中删除字符串的最后一个字符
- 如何使用 for 循环概念在 Python 中删除字符串的最后一个字符
- 如何使用连接和列表理解方法在 Python 中删除字符串的最后一个字符
- 如何使用 replace()方法在 Python 中移除字符串的最后一个字符
- 如何从字符串 Python NumPy 中删除最后一个字符
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。**
移除 python 中的 Unicode 字符
原文：https://pythonguides.com/remove-unicode-characters-in-python/
在本 Python 教程中，我们将讨论如何移除 python 中的 unicode 字符。此外，我们还将讨论:
- 从字符串 python 中移除 Unicode 字符
- Python 从字符串中删除了 Unicode“u”
- 移除 python 字符串中的特殊字符
- 移除 python 中的非 ASCII 字符
目录
- 从字符串中删除 python 中的 Unicode 字符
- Python 从字符串中移除 Unicode“u”
- 删除 python 字符串中的特殊字符
- 删除 python 中的非 ASCII 字符
从字符串中删除 python 中的 Unicode 字符
在 python 中，要从字符串 python 中删除 Unicode 字符，我们需要使用 str.encode() 对字符串进行编码，以便从字符串中删除 Unicode 字符。
举例:
string_unicode = " Python is easy \u200c to learn. "
string_encode = string_unicode.encode("ascii", "ignore")
string_decode = string_encode.decode()
print(string_decode)
写完上面的代码后(从字符串 python 中删除 Unicode 字符)，你将打印出 " string_decode " ，然后输出将显示为 " Python 很容易学。"。这里，encode()用于从字符串中移除 Unicode。你可以参考下面的截图来移除字符串 python 中的 Unicode 字符。
remove unicode characters python
Python 从字符串中移除 Unicode“u”
在 python 中，要从字符串中删除 Unicode " u " 字符，我们可以使用 replace()方法从字符串中删除 Unicode " u"。
举例:
string = "u\'Python is easy'"
string_unicode = string.replace("u'", "'")
print(string_unicode)
写完上面的代码后(python 从一个字符串中删除 Unicode“u”)，你将打印出“string _ Unicode”，然后输出将显示为“Python 很简单。”。这里，它从字符串中删除了 Unicode 码“u”。从 string python 中移除 Unicode " u " 可以参考下面的截图。
remove unicode characters python
我们也可以，do python 通过使用 encode() 从字符串中移除 Unicode“u”字符，这里的“u”是用别的东西移除的 Unicode。
举例:
string = u'hello world!'
string_encode = string.encode('ascii')
print(string_encode)
写完上面的代码后(python 从字符串中删除了 Unicode“u”字符)，您将打印出“string _ encode”，然后输出将显示为“b ' hello world！”。这里，它用别的东西从字符串中删除了 Unicode 字符“u”。你可以参考下面的截图来移除字符串 python 中的 Unicode " u " 字符。
Python remove Unicode “u” character from a string
这是怎么做到的，我们可以从字符串 **中 ****去除 Unicode“u”字符。**
删除 python 字符串中的特殊字符
在 python 中，为了删除 python 字符串中的特殊字符，我们使用 isalnum()从字符串中删除特殊字符。特殊字符可以是空格、标点符号或斜线。
举例:
my_string = "sgr /k !? 100002"
string = ""
for character in my_string:
if character.isalnum():
string = string + character
print(string)
写完上面的代码后(去掉 python 字符串中的特殊字符)，您将打印出 " string" ，然后输出将显示为 " sgrk100002 " 。在这里，它从字符串中删除特殊字符，并返回一个包含字母和数字的字符串，循环将遍历每个字符。你可以参考下面的截图来移除 python 字符串中的特殊字符。
Remove special characters in python string
这就是我们如何能够删除 python 字符串中的特殊字符。
删除 python 中的非 ASCII 字符
在 python 中，要去除 python 中的非 ASCII 字符，我们需要使用 string.encode() ，编码为 ASCII ，错误为 ignore ，返回一个没有 ASCII 字符的字符串使用 string.decode() 。
举例:
string_nonASCII = " àa fuünny charactersß. "
string_encode = string_nonASCII.encode("ascii", "ignore")
string_decode = string_encode.decode()
print(string_decode)
写完上面的代码(去掉 python 中的非 ASCII 字符)，你将打印出 " string_decode " ，然后输出将显示为"一个有趣的字符。"。这里，encode()用于从字符串中删除非 ASCII 字符，而 decode() 将对字符串进行编码。你可以参考下面的截图来移除 python 中的非 ASCII 字符。
Remove non-ASCII characters in python
这就是我们如何在 python 中移除 非 ASCII 字符。
您可能会喜欢以下 Python 教程:
- Python 中的注释行
- 偶数或奇数的 Python 程序
- Python 字典追加示例
- 在 Python 中检查列表是否为空
- Python 将列表转换成字符串
- Python 方块一号
- 什么是 Python 字典+用 Python 创建字典
- 无换行符的 Python 打印
- Python 字典方法+示例
在本教程中，我们已经讨论了如何在 python 中移除 Unicode 字符。我们用 Python 中的例子讨论了如何移除 Unicode 字符。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Replit 蟒蛇龟
在本巨蟒龟教程中，我们将学习如何使用 Replit 巨蟒龟，我们还将介绍与 Replit 龟相关的不同示例。我们将讨论这些话题。
- Replit 蟒蛇龟
- Replit Python 海龟馆
目录
Replit 蟒蛇龟
在这一节中，我们将学习 Python Turtle 中的 Replit 。Replit 是一个编码平台，我们可以在这里写代码，做项目。在这里，我们可以借助 Replit 托管应用程序。
它有不同的使用方式，可以用以下方式代替:
- 代码编辑器(相对于代码、子行)
- 像 NPM 一样建造工具
- 云服务提供商(AWS、Netlify)
- 社区协作工具(谷歌、Github)
代码:
我们从 turtle import * 、导入 turtle 模块作为 turn。
tur.pensize(8)用于增加或减少线条的粗细。tur.circle(100)用于在屏幕上画圆。
from turtle import *
import turtle as tur
tur.pensize(8)
tur.circle(100)
tur.circle(50)
tur.done()
输出:
运行上述代码后，我们可以看到下面的输出，这是使用 Replit 中的 pensize() 和 circle() 函数完成的。
Replit python turtle Output
阅读:蟒龟大小
Replit 蟒蛇龟屋
在这一节中，我们将学习如何用 Python 构建一个 Replit turtle house。
正如我们所知，replit 是一个编码平台，我们可以编写代码并执行它，甚至我们可以将应用程序托管到该平台上。在这里，我们编写了一个可以在 replit 上执行的代码，并在浏览器上托管该应用程序。
代码:
在下面的代码中，我们导入了 turtle 模块，它有助于绘制图片。
- 速度(0) 用来给乌龟速度，
0是最快的速度。 color()用于给图像着色，以获得吸引人的外观。forward()是在龟笔上移动做出形状的方向函数。left()是在龟笔上移动做出形状的方向函数。right()是在龟笔上移动做出形状的方向函数。
from turtle import *
import turtle
speed(0)
color('brown')
forward(350)
left(90)
forward(100)
color("alice blue")
begin_fill()
forward(250)
left(90)
forward(490)
left(90)
forward(250)
left(90)
forward(491)
end_fill()
color("brown")
right(90)
forward(100)
right(90)
forward(630)
penup()
left(180)
forward(180)
left(90)
forward(45)
color("dark green")
begin_fill()
right(385)
forward(170)
right(130)
forward(170)
right(115)
forward(82)
end_fill()
penup()
color("brown")
right(180)
forward(30)
pendown()
begin_fill()
right(90)
forward(45)
right(90)
forward(45)
right(90)
forward(45)
right(90)
forward(45)
end_fill()
penup()
right(90)
forward(45)
right(90)
forward(45)
#pendown()
color("brown")
forward(110)
color("brown")
right(90)
forward(105)
color("blue")
forward(105)
color("blue")
right(90)
forward(300)
right(180)
pendown()
circle(30,50)
right(90)
circle(30,50)
penup()
left(170)
forward(200)
pendown()
color("yellow")
begin_fill()
circle(60)
end_fill()
penup()
color("blue")
right(90)
forward(206)
right(90)
forward(125)
pendown()
color("black")
begin_fill()
forward(25)
right(90)
forward(40)
right(90)
forward(25)
right(90)
forward(40)
end_fill()
color("red")
left(90)
forward(50)
left(90)
forward(100)
left(90)
forward(125)
left(90)
forward(100)
left(90)
forward(50)
right(180)
forward(50)
right(90)
forward(100)
right(45)
forward(90)
right(90)
forward(90)
right(45)
penup()
forward(100)
right(90)
turtle.done()
输出:
在上面的代码中，我们使用 python turtle 模块和 forward() 、 right() color() 、 left() 函数，用 python turtlepen 制作了一张房子的图片。
在 Replit 中，我们可以在任何地方都能访问的服务器上托管我们的应用和运行我们的代码。
链接:在这个链接中，我们可以看到我们的代码是如何在 Replit 平台上工作的，我们可以访问它来查看输出。
Replit Python turtle house Output
你可能也喜欢读下面的文章。
因此，在本教程中，我们讨论了 Replit Python Turtle ,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Replit 蟒蛇龟
- Replit Python 海龟馆
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中反转列表
在本 Python 教程中，我们将学习如何在 python 中反转一个列表。我们将讨论与反转列表相关的不同例子。这是我们将要涉及的例子列表。
- 用反转函数反转 python 中的列表
- 用反向迭代器反转 python 中的列表
- 在 python 中不使用反转函数反转列表
- 如何在 python 中使用 while 循环反转列表
- 使用 for 循环反转 python 中的列表
- 使用切片反转 python 中的列表
- 使用递归在 python 中反转列表
目录
- 用反转函数反转 python 中的列表
- 用反向迭代器反转 python 中的列表
- 在 python 中不用反转函数反转一个列表
- 如何使用 while 循环反转 python 中的列表
- 使用 for 循环反转 python 中的列表
- 使用切片反转 python 中的列表
- 使用递归在 python 中反转列表
用反转函数反转 python 中的列表
Python 有一个名为 reverse() 的内置函数，我们可以用它来反转一个 Python 列表。让我们看一个例子。我们将创建一个列表，并使用 reverse() 函数来反转它。看看下面的代码。
list1=[12,14,56,24,25,52,54]
list1.reverse()
print(list1)
- 我们创建了一个名为
list1的列表，并使用 reverse()函数来反转列表。查看下面的输出:
Reversed list
这样，就可以使用内置的 reverse()函数来反转一个列表。
阅读: Python 程序反转一个字符串
用反向迭代器反转 python 中的列表
python 中还有另一个内置选项来反转列表。我们可以使用反向迭代器。使用这个选项，我们可以以相反的顺序迭代我们的列表，或者我们也可以以列表的形式存储结果。让我们看看如何。
list1= [23, 54, 76, 82, 40, 45]
for element in reversed(list1):
print(element)
Elements printed in reverse order
您可以看到元素是以相反的顺序打印的。
同样，你可以用这个反向迭代器来做一个列表。但是你必须把这个迭代器对象转换成一个列表。
list1= [23, 54, 76, 82, 40, 45]
print(list(reversed(list1)))
Reversed List
这样，你就可以使用反向迭代器在 python 中得到一个反向列表。
阅读: 11 Python 列表方法
在 python 中不用反转函数反转一个列表
当我们想在 python 中反转一个列表时，一般会使用 reverse() 函数。但是我们也可以编写自己的逻辑来完成同样的任务。
在下面几节中，我解释了一些不用 reverse() 函数就可以在 python 中反转列表的方法。
如何使用 while 循环反转 python 中的列表
在 python 中，可以使用 while 循环来反转列表。看看下面的代码:
list1= [54,78,23,54,67,90,12,43]
print('Original list:', list1)
list2=[]
length=len(list1)
while length > 0:
list2.append(list1[length-1])
length = length - 1
print('Reversed list:', list2)
Reversed list
- 在上面的代码中，我们迭代了列表的长度。我们递减长度的值，当长度为零时，循环将停止。
- 在索引的帮助下，我们将原始列表的值存储到一个新列表中。
这样，您可以使用 while 循环来反转 python 中的列表。
阅读: Python 将数据帧转换为列表
使用 for 循环反转 python 中的列表
还可以使用 for 循环来反转 python 中的列表。我将解释使用 for 循环反转列表的各种例子。
例 1:
考虑以下 python 代码:
original_list=[71, 36, 51, 75, 82, 78, 40]
print('Orginal List:', original_list)
reversed_list=[]
for i in original_list:
reversed_list.insert(0,i)
print('Reversed List:', reversed_list)
Reversed List
-
在上面的例子中，我们使用了
insert()函数在新列表的第一个位置插入一个元素。 -
当我们在列表中的第一个索引处插入一个元素时，其余的元素被转移到下一个索引处。
-
例如，以下是每次迭代后反转列表的值:
[71]- [36, 71]
- [51, 36, 71]
- [75, 51, 36, 71]
- [82, 75, 51, 36, 71]
- [78, 82, 75, 51, 36, 71]
- [40, 78, 82, 75, 51, 36, 71]
-
你可以看到，在所有迭代结束时，我们的列表是颠倒的。
现在让我们看另一个使用 for 循环反转列表的例子。
例 2:
在这个例子中，我们将使用列表的 insert() 函数和 pop() 方法来反转列表。pop()方法删除列表的最后一个元素，并返回这个被删除的值，我们可以将它存储到一个变量中。
这一次，我们不会创建一个新的列表，而只会反转现有列表中的元素。
original_list=[71, 36, 51, 75, 82, 78, 40]
print('Orginal List:', original_list)
for i in range(len(original_list)):
popped= original_list.pop()
original_list.insert(i, popped)
print('Reversed List:', original_list)
Reversed List
- 我们使用 pop()方法删除最后一个元素，并将这个删除的元素存储到一个变量中。
- 然后我们使用 insert()函数在列表中插入弹出的元素。
- 为了更好地理解它，您可以在每次迭代后看到列表的值:
- [71, 36, 51, 75, 82, 78, 40]
- [40, 71, 36, 51, 75, 82, 78]
- [40, 78, 71, 36, 51, 75, 82]
- [40, 78, 82, 71, 36, 51, 75]
- [40, 78, 82, 75, 71, 36, 51]
- [40, 78, 82, 75, 51, 71, 36]
- [40, 78, 82, 75, 51, 36, 71]
- [40, 78, 82, 75, 51, 36, 71]
因此，您可能已经学会了如何在 for 循环中使用 pop()和 insert()函数来反转列表。
例 3 :
在这个例子中，我将解释一种不使用内置函数的非常有效的反转列表的方法。看看下面的代码；
list1 = [32, 65, 79, 45, 35, 62, 74]
print('Original List:', list1)
Length = len(list1)
for i in range(int(Length / 2)):
temp = list1[i]
list1[i] = list1[Length - i - 1]
list1[Length - i - 1] = temp
print('Reversed List:', list1)
Reversed List
- 在上面的代码中，循环将运行列表中一半数量的元素。
- 这意味着运行该程序的时间复杂度将低于其他一些方法，使其成为一个非常有效的解决方案。
代码的解释 :
- 在上面的程序中，我们试图在一个循环内将左侧的一个元素与右侧的相应元素交换。
- 使用这个逻辑，我们只需要运行这个程序列表中元素总数的一半。
- 让我一个一个给你看迭代:
原列表:【32，65，79，45，35，62，74】
列表长度: 7
迭代次数: int(7/2) = 3
迭代 1:
[74, 65, 79, 45, 35, 62, 32]
迭代 2:
[74, 62, 79, 45, 35, 65, 32]
迭代 3:
[74, 62, 35, 45, 79, 65, 32]
你可以看到在最后一次迭代中，我们颠倒了我们的列表。通过这种方式，您可以使用 for 循环以非常高效的方式来反转 python 中的列表。
例 4:
下面的例子只是为了实践，并不是一个可行的解决方案，因为它有很高的空间和时间复杂度。
在这个方法中，我们迭代原始列表元素。我们将每个元素转换成一个列表，并将它与最初为空的新列表连接起来。
original_list=[71, 36, 51, 75, 82, 78, 40]
print('Original List:', original_list)
reversed_list=[]
for element in original_list:
reversed_list= [element] + reversed_list
print('Reversed List:', reversed_list)
Reversed List
阅读: Python 字符串列表
使用切片反转 python 中的列表
在本节中，您将学习如何使用切片方法来反转列表。在这个方法中，我们必须制作一个新的列表副本。这增加了程序的空间需求。
看看下面的代码:
list1=[44, 75, 24, 78, 24, 84, 24]
print('Original List', list1)
new_list=list1[::-1]
print('Reversed List', new_list)
Reversed List
您可以看到列表的副本以相反的顺序存储元素。这样，您可以使用切片或索引方法来获得逆序列表。
使用递归在 python 中反转列表
在 python 中，还可以使用一些递归方法来反转列表。让我们借助一个例子来理解。
list1= [43, 56, 23, 75, 92, 34, 45]
print('Original list:', list1)
def rev(lst):
if len(lst) == 0:
return []
return [lst[-1]] + rev(lst[:-1])
print('Reversed list:', rev(list1))
Reversing a list using recursion
- 在上面的代码中，我们创建了一个递归函数。
- 这个函数返回列表的最后一个元素，并将它转换成一个列表。
- 然后这个函数使用连接操作符并再次调用自己，但是这次传递的列表不包括列表的最后一个元素。
- 因此，该函数将递归地返回从最后一个位置到第一个位置的所有元素，并在最后一次迭代中连接它们。
- 这将返回一个逆序的列表。
让我形象地解释一下:
原始列表:版本([43，56，23，75，92，34，45])
迭代 1:
现在这个函数将分解为:
[45] + rev([43，56，23，75，92，34])
迭代 2:
类似地，该函数将再次分解为:
[45] + [34] + rev([43，56，23，75，92])
迭代 3:
[45] + [34] + [92] + rev([43，56，23，75])
第四次迭代:
[45] + [34] + [92] + [75] + rev([43，56，23])
迭代 5:
[45]+[34]+[92]+[75]+[23]+rev([43，56])
迭代 6:
[45]+[34]+[92]+[75]+[23]+[56]+rev([43])
这相当于:
[45] + [34] + [92] + [75] + [23] + [56] + [43] = [45, 34, 92, 75, 23, 56, 43]
因此在最后一次迭代中，我们颠倒了我们的列表。通过这种方式，你可以使用递归方法来反转 python 中的列表。
您可能也喜欢阅读以下 python 教程。
- Python 循环遍历 列表
- 在 Python 列表中找到最小的数字
- Python 查找列表中元素的索引
- Python 统计文件中的字数
- Python 在字符串中查找数字
- Python 元组排序列表
- Python NumPy to list
- Python 字典值列表
- 在 Python 中检查列表是否为空
- 如何在 Python 中把列表转换成字符串
因此，你可能已经学会了用 python 反转列表的各种方法。下面是我们上面讨论过的方法列表。
- 用反转函数反转 python 中的列表
- 用反向迭代器反转 python 中的列表
- 在 python 中不使用反转函数反转列表
- 如何在 python 中使用 while 循环反转列表
- 使用 for 循环反转 python 中的列表
- 使用切片反转 python 中的列表
- 使用递归在 python 中反转列表
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中反转一个数字[11 种不同的方法]
你知道如何在 Python 中 反转一个数字吗？本教程将讨论如何在 Python 中 反转一个数字。此外，我们还将讨论以下主题。
- 在 python 中反转数字
- 如何在 Python 中使用 for 循环反转一个数字
- 在不使用 for 循环的情况下在 Python 中反转一个数字
- 在 Python 中使用函数反转数字
- 使用 while 循环反转 Python 中的数字
- 如何在 Python 中使用递归反转一个数字
- 在 Python 中使用内置函数反转一个数字
- 不使用内置函数在 Python 中反转一个数字
- 在 Python 中使用切片反转一个数字
- 如何在 Python 中反转数字的顺序
- 如何在 Python 中反转列表中的数字
- 反转一个数字，检查它是否是 Python 中的回文
- Python 中的反向字符
目录
- 在 python 中反转一个数字
- 使用 for 循环在 Python 中反转一个数字
- 在不使用 for 循环的情况下用 Python 反转一个数字
- 使用函数在 Python 中反转一个数字
- 使用 while 循环在 Python 中反转一个数字
- 使用递归在 Python 中反转一个数字
- 在 Python 中使用内置函数反转一个数字
- 使用切片在 Python 中反转一个数字
- 如何反转 Python 中的数字顺序
- 在 Python 中反转列表中的数字
- 反转一个数字，检查它是否是 Python 中的回文
- Python 中的反向字符
在 python 中反转一个数字
- 当一个数反转时，它的数字排列是第一个数字在前，最后一个数字在后，倒数第二个数字在后，以此类推，最后一个数字在最后。
- Python 中的列表方法、切片方法、递归方法和其他预定义方法可以与条件语句结合使用，以创建反向逻辑函数。对任何类型的用户提供的输入执行这个过程的最简单的方法是使用 reverse()方法。
以数学方式对数字进行简单的逻辑反转:
首先，我们将一个整数除以 10，直到余数不会以相反的顺序出现。
第一次迭代:
num= 675
Reminder = num %10
Reminder = 675%10 = 5
# Second iteration
reminder = Num%10
reminder = 67 %10 = 7
举例:
通过使用切片方法，我们可以很容易地得到 Python 中原始输入数的倒数。
源代码:
new_number = 76354
print(str(new_number)[::-1])
您可以通过使用字符串切片方法获得反转的字符串。开始:停止:步骤的值为-1。当您将-1 作为一个步骤传递时，起点移动到起点，并在终点停止。
下面是以下给定代码的实现
Reverse a number in python
这就是我们如何在 Python 中反转一个输入数字。
阅读: Python 程序求偶或奇
使用 for 循环在 Python 中反转一个数字
- 通过利用 for 循环和原始字符串后面的字符，我们可以使用这种技术来反转一个数字。以这种方式，创建了一个新的字符串，该字符串是颠倒的，因为首先添加最后一个字符，然后是倒数第二个，依此类推，最后添加第一个字符。
- 使用 input()或 raw_input()方法，可以读取输入的数字。接下来，确定输入的值是否是整数。现在检查提供的数字是否大于零。
- 创建一个名为“reverse”的变量，并将其初始值设置为“0”利用 mod (%)运算符，找出指定输入数字的剩余部分。将变量 reverse 乘以 10 后的剩余值相加。
举例:
input_number = '6783'
result = ''
for m in range(len(input_number), 0, -1):
result += input_number[m-1]
print('The reverse number is =', result)
在这个例子中，我们首先声明一个变量，并给它分配一个整数，然后使用 for 循环方法和 len()方法。
下面是下面给出的代码的截图。
Reverse a number in Python using for loop
在这个例子中，我们已经了解了如何使用 for 循环方法在 Python 中反转一个数字。
在不使用 for 循环的情况下用 Python 反转一个数字
- 本节将讨论如何在不使用 for 循环的情况下在 Python 中反转一个数字。
- 该值必须首先由用户输入，并存储在变量 n 中。执行 while 循环，并利用模数运算符来确定数字的最后一位。然后，下一个数字保持在位置 1，倒数第二个数字保持在位置 10，依此类推。
- 最后一步是将数字除以 10，去掉最后一个数字。当数字的值为 0 时，循环结束，数字打印在背面。
举例:
new_number = int(input("Enter the value: "))
result = 0
while(new_number>0):
remainder = new_number % 10
result = (result * 10) + remainder
new_number = new_number//10
# Print the result
print("Reverse number:",result)
在这个例子中，我们将设置条件，如果输入的数字小于 0，那么它将除以 10 并显示结果。
你可以参考下面给出的代码截图
Reverse a number in Python without using for loop
这就是我们如何在不使用 for-loop 方法的情况下在 Python 中反转一个数字。
阅读: Python 方块一号
使用函数在 Python 中反转一个数字
- 在这个例子中，我们将使用 reversed()函数获得 Python 中一个数字的倒数。
- reversed()函数返回一个对象，以逆序遍历组件，但实际上并不反转任何内容。reversed()方法提供了一个迭代器来帮助以逆序遍历所提供的列表，但是它会修改列表。
- 为了反转一个数字，我们可以很容易地使用 Python reversed()函数。可以反向迭代字符串或列表的指针是函数的返回值。之后，我们可以使用 Python 的 join()方法从这个迭代器中提取反转的数字。
举例:
new_number = 65783
con_str = str(new_number)
#By using the reversed method
result = "".join(reversed(con_str))
#Display reversed number
print("Reversed Number is:",result)
在下面给出的代码中，我们首先声明输入数字，然后将数字转换成字符串。之后，我们使用 reversed()函数，并将转换后的字符串赋给它。执行此代码后，它将显示原始数字的倒数。
下面是以下给定代码的执行过程
Reverse a number in Python using the function
这就是我们如何在 Python 中使用 reversed 函数来反转一个数字。
阅读: Python 打印无换行符
使用 while 循环在 Python 中反转一个数字
- 在这里，我们将讨论如何使用 while 循环概念来获取 Python 中原始数字的倒数。
- 我们需要首先添加最后一位数字，因为我们将开始一个新的变量来保存我们的倒计数。我们可以在 while 循环中取这个数的 10 的模来获得最终的数字。最后一个数字将揭示这个问题的解决方案。
举例:
new_number = 8656
new_output = 0
while new_number != 0:
new_val = new_number % 10
new_output = new_output * 10 + new_val
new_number //= 10
print("Display the reversed Number: " + str(new_output))
下面是以下代码的截图
Reverse a number in Python using a while loop
正如你在截图中看到的，我们已经学会了如何使用 while 循环概念来获取 Python 中原始数字的倒数。
阅读: 11 Python 列表方法
使用递归在 Python 中反转一个数字
- 递归用于以这种方式反转一个数。递归的缺点是它允许无限调用递归函数，直到到达最后一个索引。
- 然后，在这个基本实例中，可以将字母添加到生成的反向字符串中，这将作为我们的起点。将首先插入最后一个索引，然后是倒数第二个索引，依此类推，最后添加第一个索引。因此，通过首先使用递归函数，然后添加字母，我们可以反转字符串。
举例:
new_num = 0
def reverse(new_val):
global new_num
if(new_val > 0):
Reminder = new_val %10
new_num = (new_num *10) + Reminder
reverse(new_val //10)
return new_num
new_val = int(input(" Enter the number : "))
new_num = reverse(new_val)
print(" The Result reverse number is:",new_num)
下面是以下给定代码的输出
Reverse a number in Python using recursion
这是如何在 Python 中通过使用递归方法来反转一个数字。
阅读: Python 命名约定
在 Python 中使用内置函数反转一个数字
- 这里我们讨论如何使用 Python 中的内置函数来反转一个数字。
- Python 中具有预定义功能的函数称为内置函数。Python 解释器上随时都有各种函数可供使用。
- 在这个例子中，我们将使用 Python 中提供的 reversed()内置函数，Python 有一个名为 reversed 的内置方法，它返回一个已被反转的序列的迭代器。
举例:
让我们举一个例子，并检查如何通过使用内置函数在 Python 中反转一个数字。
源代码:
def new_number(m):
result = ''.join(reversed(m))
return result
new_val = input('Enter the value: ')
# Display the result
print('Reverse number is:', new_number(new_val))
你可以参考下面的截图
Reverse a number in Python using an inbuilt function
在这个例子中，我们已经了解了如何通过使用内置函数来反转 Python 中的数字。
阅读: Python 添加示例
使用切片在 Python 中反转一个数字
- 在这种方法中，我们将使用字符串切片技术反转数字。首先将数字转换为字符串，然后使用 Python 语言的字符串切片功能将字符串分割并以相反的顺序相加。我们将对给定的整数输入执行以下操作。
- 将数字的格式更改为字符串，然后利用字符串切片来反转数字。
- 通过使用这种技术，我们可以使用字符串切片方法来反转一个数字。在 Python 中，切片是检索字符串的子串的过程。
举例:
让我们举一个例子，检查如何通过使用切片方法在 Python 中反转一个数字。
new_num = 73485
str_val = str(new_num)
m = len(str_val )
result = str_val [m::-1]
#output reversed number
print("Reversed Number is:", result)
下面是以下给定代码的实现
Reverse a number in Python using slicing
正如你在截图中看到的，我们已经学习了如何使用切片方法在 Python 中反转一个数字。
如何反转 Python 中的数字顺序
- 在这一节中，我们将讨论如何在 Python 中反转数字的顺序。
- 通过将输入变量从输入数字的后面移到前面，可以反转数字。当一个数反转时，它的数字排列是第一个数字在前，最后一个数字在后，倒数第二个数字在后，以此类推，最后一个数字在最后。
举例:
input_number = '5678'
result = ''
for m in range(len(input_number), 0, -1):
result += input_number[m-1]
print('The reverse number is =', result)
你可以参考下面的截图
How to reverse the order of numbers in Python
在这个例子中，我们已经理解了如何在 Python 中反转数字的顺序。
阅读: Python 对于基数为 10 的 int()无效文字
在 Python 中反转列表中的数字
- 在这种技术中，我们利用了 Python 中的列表提供 reverse()方法来翻转列表元素的事实。
- 因此，使用 Python 的 list()函数，我们只需将我们的数字添加到列表中，反转它们以获得相反的顺序，然后将它们合并以获得最终的反转数字。
- 要将一个字符串与一个 iterable 对象结合起来，可以使用 Python 的 join()函数。结果，iterable 的字符串被连接起来创建一个全新的字符串。如果 iterable 包含任何非字符串值，它将引发 TypeError 异常。
示例:
new_num = "9432"
# Convert input num into list
new_lis = list(new_num)
# By using the reverse() method
new_lis .reverse()
#converting list into number
new_num = ''.join(new_lis )
print (" Result of input number is: ", new_num)
下面是以下给定代码的输出。
Reverse a number in a list in Python
这就是我们如何在 Python 中创建列表中的反向数字。
阅读:Python 中的注释行
反转一个数字，检查它是否是 Python 中的回文
- 回文是由字母组成的一个单词或一组数字，当向前和向后阅读时，这些字母拼成同一个单词。Python 回文允许回文单词中包含标点、符号、字母和空格。
- 当反转时，一个数必须保持不变，才有资格成为回文。如果数字不等于它本身的倒数，它就不是一个回文。
举例:
new_val=input(("Enter the value:"))
new_reverse = int(str(new_val)[::-1])
if new_val == new_reverse:
print('It is Not Palindrome')
else:
print("It is Palindrome")
下面是以下代码的截图
Reverse a number and check if it is a palindrome in Python
阅读: Python 检查变量是否为整数
Python 中的反向字符
- 在这一节中，我们将讨论如何在 Python 中反转一个字符或字符串。
- 在本例中，我们将创建一个向后移动并从字符串末尾开始的切片。
- 在这种情况下，片段短语[::-1]表示向后移动一步，从位置 0 开始，到字符串的末尾结束。
举例:
new_char = "USA" [::-1]
print(new_char)
下面是以下给定代码的实现
Reverse character in Python
另外，看看更多的 Python 教程。
- 如何在 Python 中从路径中获取文件名
- 在 Python 中检查一个字符串是否包含子串
- 面向对象编程 python
- 如何在 Python 中寻找完全数
- Python 读取 CSV 文件并写入 CSV 文件
在本文中，我们将讨论如何在 Python 中反转一个数字。此外，我们还将讨论以下主题。
- 在 python 中反转数字
- 使用 for 循环反转 Python 中的数字
- 在不使用 for 循环的情况下在 Python 中反转一个数字
- 在 Python 中使用函数反转数字
- 使用 while 循环反转 Python 中的数字
- 使用递归在 Python 中反转一个数字
- 在 Python 中使用内置函数反转一个数字
- 不使用内置函数在 Python 中反转一个数字
- 在 Python 中使用切片反转一个数字
- 如何在 Python 中反转数字的顺序
- 在 Python 中反转列表中的数字
- 反转一个数字，检查它是否是 Python 中的回文
- Python 中的反向字符
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
点击 Django 中的 HTML 按钮运行 Python 函数
原文：https://pythonguides.com/run-python-function-by-clicking-on-html-button-in-django/
在本 Python Django 教程中，我将讲解如何通过点击 DjangoT5 中的 HTML 按钮来运行 python 函数。
在进行 Django 项目时，我需要一个 HTML 按钮来调用 python 函数。所以，我做了研究，并最终创建了一个 HTML 按钮，点击打印表乘法。
所以，在这里我们会看到:
- 如何在 Django 建立项目
- 如何在 Django 中创建 HTML 按钮来执行 python 函数
- 通过点击 Django 中的 HTML 按钮运行 Python 函数来获得乘法表
- 如何在 Django 模板标签中使用 for 循环
- 如何在 Django 中使用范围函数
- 使用 FormClass 创建 Django 表单
在本文的最后，您可以通过点击一个 HTML 按钮来下载执行 python 脚本的代码。
这是我们将在这里建造的。
Run Python function by clicking on HTML Button in Django to get multiplication table
目录
点击 Django 中的 HTML 按钮运行 Python 函数
现在，让我们一步一步地看看如何在 Django 中点击按钮运行 Python 函数并显示表乘法。
建立 Django 项目
首先，我们需要使用下面给出的命令在 Django 中建立一个项目。这里 HTMLButtonProject 是项目的名称。
django-admin startproject HTMLButtonProject
在 Django 项目中，使用如下命令创建一个名为 MyApp 的 Django 应用程序。
python manage.py startapp MyApp
Set Up Django Project
打开项目目录下的 settings.py 文件，将 MyApp 添加到 INSTALLED_APP 列表中。
Install MyApp
Django 中的请求首先到达位于项目目录中的 urls.py ，然后到达 app 目录中 urls.py 中的匹配 URL。在其中添加下面的代码。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('MyApp.urls')),
]
此外，检查:Django 中的应用程序和项目之间的差异
创建 Django 表单
创建 Django 表单， MyApp 应用程序将使用该表单从用户处接收数字输入。将以下代码添加到我们在 app 目录中创建的 forms.py 文件中。
from django import forms
class TableForm(forms.Form):
num = forms.IntegerField(label='Please Enter Number:')
这里，我们使用表单创建一个表单。表单类命名为表格表单。它有号作为 Django 整数字段。此外，我们通过传递 label 关键字来更改它的标签。
点击 Django 中的 HTML 按钮运行 Python 函数，得到乘法表
在主项目目录中创建一个名为 Templates 的子目录来存储 Django 应用程序的 HTML 文件。
打开 settings.py 文件，更新 DIRS 指向 Templates 文件夹的位置。
Set Templates Folder Location
要在 HTML 按钮 click 上定义表格乘法函数的前端，在模板文件夹中创建一个名为home.html的 HTML 文件。并添加下面的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Table Multiplication</title>
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.0.0/dist/css/bootstrap.min.css"
integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
</head>
<body>
<div class="mt-md-5">
<div class="pl-sm-5">
<div class="pr-sm-5">
<h3 align="center">Welcome to PythonGuides</h3>
<br>
<hr>
<form method="POST">
{% csrf_token %}
<table>
{{ form.as_table }}
</table>
<button type="submit" class="btn btn-success">Print Table</button>
</form>
<br>
<hr>
<p>Number to print its multiplication table:{{Number}}</p>
<br>
<hr>
{% for x in range %}
{{ Number }} x {{x}} = {% widthratio Number 1 x %} <br>
{% endfor %}
</div>
</div>
</div>
<!-- jQuery first, then Popper.js, then Bootstrap JS -->
<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/popper.js@1.12.9/dist/umd/popper.min.js"
integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@4.0.0/dist/js/bootstrap.min.js"
integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
crossorigin="anonymous"></script>
</body>
</html>
- 首先，通过在任何其他样式表之前添加样式表到页面标题的链接来加载 CSS。
- 然后，分别使用 div 类 mt-md-5 、 div 类 pl-sm-5 和 div 类 pr-sm-5 来添加引导填充和间距。
- 为了构建我们用来从用户输入数字的表单，我们使用了带有
POST方法的form标签。然后，使用csrf_token保护表单免受网络攻击，使用form.as_table以表格格式呈现表单字段。 - 添加一个提交按钮来打印乘法表。并且，使用
p标签打印乘法表。然后，我们将使用循环的从序列中一次获取一个值。 - 然后，我们使用这个单一值来获得输入数字的表乘法。为了得到表格乘法，我们使用了一个
widthratio过滤器，在过滤器中，(Number 1 x)的意思就是(Number * x)。 - 另外，我们使用
h3、br和hr标签分别添加标题、换行和水平线。
定义视图
要定义主逻辑，打开 views.py 文件并添加下面给出的代码。
from django.shortcuts import render
from .forms import TableForm
# Create your views here.
def html_button(request):
if request.method == "POST":
form = TableForm(request.POST)
if form.is_valid():
num = form.cleaned_data['num']
return render(request, 'home.html', {'Number':num, 'range': range(1,11)})
else:
form = TableForm()
return render(request,'home.html',{'form':form})
- 首先，从
forms.py中导入TableForm并创建一个名为html_button的视图。 - 然后调用
if语句，检查请求方法是否为POST。- 如果是，我们通过 TableForm(请求。POST) 将数据绑定到表单类，这样我们就可以进行验证。
- 现在，调用
is_valid方法来验证用户输入的内容，如果验证成功，调用表单cleaned _ data[‘表单域’]来验证数据。 - 用
num和range()函数返回home.html，通过传递给render函数得到一个从 1 到 10 的数字列表。
- 如果请求方法是
GET，用户将看到一个空白的输入字段，使用render()函数输入数字。
现在，我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。包括下面的代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.html_button, name='htmlbutton'),
]
执行 Django 应用程序
要启动开发服务器，请在终端中键入下面给出的命令并运行服务器。
python manage.py runserver
它成功地打开了用于做表乘法的网页，如下所示。
Run Python Function on HTML Button Click
现在，填写您要打印其表格的号码，然后单击“打印表格”按钮。
Table Multiplication Web Page
例如，我在这里输入数字 7，单击打印表格按钮，它将打印 7 的表格。
HTML Button Click Python
这就是我们如何通过使用 Django 点击 HTML 按钮来运行 Python 函数。
点击 Django 中的 HTML 按钮，下载运行 Python 函数的完整代码
代码如下:
Execute Python Function on HTML Button click
结论
这样，我们就成功地创建了一个 Python 函数，它将在单击 HTML 按钮时执行。我们还学习了使用 form 类创建一个表单，该表单将接受用户在 integer 字段中的输入。
此外，我们还讨论了以下主题
- 如何在 Django 建立项目
- 如何在 Django 中创建 HTML 按钮来执行 python 函数
- 通过点击 Django 中的 HTML 按钮运行 Python 函数来获得乘法表
- 如何在 Django 模板标签中使用 for 循环
- 如何在 Django 中使用范围函数
- 使用 FormClass 创建 Django 表单
另外，请查看以下关于 Python Django 的教程
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
在 Django 中运行 Python 脚本
当您有了一种处理 web 开发和 Python 的新方法时，您可能偶尔需要在一个 Django 项目或 shell 中运行 Python 脚本。有多种方法可以做到这一点。在本文中，我们将研究运行 Python 脚本的各种 Django 方法。还有，我已经讲了这几点:—
- 如何使用 shell 在 Django 项目中运行 Python 脚本
- 如何使用 execfile 在 Django 中运行 Python 脚本
- 如何使用扩展包在 Django 中运行 Python 脚本
目录
使用 shell 在 Django 项目中运行 Python 脚本
我们先来了解一下什么是 Python 脚本。
打算立即执行的 Python 文件被称为脚本。当你运行它的时候，它应该立即行动。因此，脚本经常包含在任何类或函数的参数之外编写的代码。
运行 Python 脚本和管理文件位于同一个文件夹
现在，让我们学习使用 shell 在 Django 项目中运行 Python 脚本。
- 首先，使用下面给出的命令在 Django 中创建一个项目(名为“my project”)。
django-admin startproject MyProject
- 现在，在 Django 项目的 manage.py 文件所在的同一个文件夹中创建一个 python 文件(名为 "sample.py" )。
# Program to add two numbers
# Define number
num1 = 15
num2 = 26
# Add number
result = num1 + num2
# Print result
print('Sum of the two number:', result)
这里，我们定义了 num1 和 num2 两个具有整型值的变量。接下来，我们使用 + 操作符定义将 num1 和 num2 相加的结果变量。最后调用 print() 函数打印两个数之和。
- 导航到 Django 项目的根文件夹，其中有 manage.py 文件。
Navigate to the manage.py file folder
- 键入下面给出的命令，使用 shell 在 Django 项目中运行 Python 脚本 "sample.py" 。
manage.py shell < sample.py
Run Python Script in Django Project
当 Python 脚本和管理文件位于同一个文件夹中时，这就是如何使用 shell 在 Django 项目中运行 Python 脚本。
运行 Python 脚本并管理位于不同文件夹的文件
现在，让我们学习使用 shell 在 Django 项目中运行 Python 脚本。
- 首先，使用下面给出的命令在 Django 中创建一个项目(名为“my project”)。
django-admin startproject MyProject
- 现在，在任何其他位置创建一个 python 文件(名为 "xyz.py" )。
# Program to multiple two numbers
# Define number
num1 = 23
num2 = 5
# Multiply number
result = 23 * 5
# Print result
print('Product of two number:'. result)
这里，我们定义了 num1 和 num2 两个具有整型值的变量。接下来，我们使用 *** 运算符定义将 num1 和 num2 相乘的结果变量。最后调用 print() 函数打印两个数的乘积。
- 导航到 Django 项目的根文件夹，其中有 manage.py 文件。
- 键入下面给出的命令，使用 shell 在 Django 项目中运行 Python 脚本“xyz.py”。
manage.py shell < C:\Users\PythonGuides\Desktop\xyz.py
Run Python Script in Django Project
这就是当 Python 脚本和管理文件不在同一个文件夹中时，如何使用 shell 在 Django 项目中运行 Python 脚本。
使用 execfile 在 Django 中运行 Python 脚本
我们先来了解一下什么是 execfile。
execfile 或 exec 是评估文件内容的 python 方法。
现在，让我们学习使用 execfile 在 Django 项目中运行 Python 脚本。
- 首先，使用下面的命令在 Django 中创建一个名为“my project”的项目。
django-admin startproject MyProject
- 现在，在您选择的任何位置创建一个 python 文件(名称为“ABC . py”)。
# Python program to swap two variables
# To take inputs from the user
a = input('Enter value of x: ')
b = input('Enter value of y: ')
# create a temporary variable and swap the values
temp = a
a = b
b = temp
# Print the result
print('The value of a after swapping: {}'.format(a))
print('The value of b after swapping: {}'.format(b))
这里，我们定义了两个名为 a 和 b 的变量，它们通过 input() 方法接受用户输入。然后将第一个变量 a 的值存储在临时变量 temp 中。
然后将第二个变量 b 的值赋给变量 a 。最后，通过给变量 b 赋予临时变量 temp 给定值，我们完成了在两个变量之间交换值的过程。
使用 print() 方法最终打印交换的值。
-
导航到 Django 项目的根文件夹，其中有 manage.py 文件。
-
现在，通过键入下面给出的命令登录 Django shell。
manage.py shell
- 键入下面给出的命令，使用 execfile 在 Django 项目中运行 Python 脚本 "abc.py" 。
exec(open(''C:/Users/PythonGuides/Desktop/abc.py'').read())
Run Python Script in Django Project
这就是当 Python 脚本和管理文件位于任何位置时，如何使用 exec 在 Django 项目中运行 Python 脚本。
如何使用扩展包在 Django 中运行 Python 脚本
有时候你对网站开发有新的想法，但是我们对此并不确定。这个新想法可以是任何脚本，包括数据加载、处理和清理。
因此，实现业务逻辑的理想方式通常不是直接将其放在视图或模型中。此时，您可以将 Django 扩展作为一个包安装，这样就可以运行额外的脚本。
现在，让我们学习使用扩展包在 Django 项目中运行 Python 脚本。
- 如您所知，Django 扩展是一个允许您运行额外脚本的包。你必须先用 pip 安装它。打开终端窗口并键入。
pip install django-extensions
Install django-extensions
- 通过在终端中键入下面给出的命令，创建一个 Django 项目“Course”。
django-admin startproject Course
- 通过在终端键入以下命令，在 Django 项目中创建一个 Django 应用程序“Register”。
python manage.py startapp Register
- 在位于 settings.py 文件的已安装 app 列表中添加“DJ nago-extensions”包和“注册” app。
Settings.py
- 默认情况下，Django 在项目下有一个 urls.py 文件。Django 建议将新创建的应用程序“注册”映射到其中。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path("admin/", admin.site.urls),
path('', include('Register.urls'))
]
- 创建 Django 模型，定义我们将要存储的“Register”应用程序数据的字段和行为。在 Django app 中打开 models.py 文件，添加下面的代码。
from django.db import models
# Create your models here.
class CourseRegister(models.Model):
title = models.CharField(max_length = 500)
author = models.CharField(max_length=200)
def __str__(self):
return self.author
在这里，我们创建了模型类“course register”，它具有以下数据库字段。
- 标题:博文的标题。
- 作者:写帖子的人。
并使用 def str(self) 来更改 Django 模型中对象的显示名称。当我们返回自己的作者时，它将呈现作者的名字。
- 要在管理站点注册一个模型“course register”，打开 admin.py 文件并添加下面给出的代码。
# Register your models here.
from django.contrib import admin
from .models import CourseRegister
admin.site.register(CourseRegister)
- 为了映射视图，在 app 目录下创建一个 urls.py 文件，并在其中添加下面给出的代码。
from django.urls import path
from Register import views
urlpatterns = [
path('', views.home, name='home'),
]
- 视图是接收 web 请求并返回 web 响应的 Python 函数或类。将下面给出的代码添加到 app 目录下的 views.py 文件中。
from django.shortcuts import render
# Create your views here.
def home():
print('Hello')
- 要为模型创建一个迁移，使用下面给出的命令。在迁移文件夹中，将创建一个迁移文件。
python manage.py makemigrations
- 创建一个迁移，然后迁移它以反映数据库。下面是 migrate 命令。
python manage.py migrate
- 要创建超级用户，请在终端中键入以下命令。
python manage.py createsuperuser
- 要在“course register”模型中添加记录，请打开管理应用程序并添加它。
Admin Site
- 在项目目录中创建一个脚本文件夹来添加额外的 Python 脚本。
- 创建 init。脚本文件夹中的 py 文件，表明脚本也是 Django 项目的一部分。
- 创建一个新文件 "sample.py" ，它将包含您需要执行的代码。在其中添加下面给出的代码。
from Register.models import CourseRegister
def run():
result = CourseRegister.objects.all()
print(result)
为了在运行服务器之前从 CourseRegister 模型中获取所有对象，我们创建了这个额外的脚本，它有一个函数 run 。
- 现在，通过键入下面给出的命令运行脚本 sample 。
python manage.py runscript sample
Run Script
这就是如何使用扩展包在 Django 中运行 Python 脚本。
您可能也喜欢阅读下面的 Python Django 教程。
- 模型 Django 上的联合操作
- 在 Python Django 中登录系统
- Python Django 随机数
- Python 改 Django 版本
结论
在本文中，我们从 Django 学习了三种不同的运行 Python 脚本的方法。此外，我们还讨论了以下主题。
- 如何使用 shell 在 Django 项目中运行 Python 脚本
- 如何使用 execfile 在 Django 中运行 Python 脚本
- 如何使用扩展包在 Django 中运行 Python 脚本
拥有丰富 Django 和 Matplotlib 经验的 Python 开发人员，目前在 TSInfo Technologies 工作。我正在成为专业程序员、博客写手和 YouTuber 的路上。
Scikit 学习准确性 _ 分数
在本 Python 教程中，我们将了解 python 中的sci kit learn accuracy _ score，我们还将涵盖与sci kit learn accuracy _ score相关的不同示例。我们将讨论这些话题。
- scikit 学习准确性 _ 分数
- scikit 学习准确性 _ 分数示例
- scikit 如何学习 accuracy_score 的工作原理
目录
Scikit 学习准确度 _ 分数
accuracy_score 方法用于计算 Python Scikit learn 中正确预测的派系或计数的准确度。
从数学上来说，它代表了所有预测中真阳性和真阴性之和的比率。
Accuracy Score = (TP+TN)/ (TP+FN+TN+FP)
在这里，我们还可以借助 sklearn 的 accuracy_score 方法来计算准确度。
accuracy_score(y_true, y_pred, normalize=False)
在多标签分类中，函数返回子集精度。如果样本的整个预测标签集与真实标签集精确匹配。那么子集的精度是 1.0，否则，它的精度几乎是 0.0。
语法:
sklearn.metrics.accuracy_score(y_true,y_pred,normalize=False,sample_weight=None)
参数:
- y_true: 标签指示数组/稀疏矩阵正确标签。
- y_pred: 分类器返回的标签指示数组/稀疏矩阵预测标签。
- 规格化:包含布尔值(真/假)。如果为假，则返回正确机密样本的数量。否则，它返回正确机密样本的分数。
退货:
分数:浮动
- 如果 normalize == True，则返回正确机密样本的数量(float)，否则返回正确机密样本的数量(int)。
- 最佳性能是归一化真时的 1，归一化假时的样本数。
我们也可以用以下方式编写 accure_score:
accuracy_score(
y_true,
y_pred,
normalize: bool=True,
sample_weight:__class__ =None
)
scikit 学习准确性 _ 分数示例
正如我们所知，scikit learn library 用于专注于数据建模，而不是专注于加载和操作数据。这里我们可以使用 scikit learn accuracy_score 来计算数据的准确性。
例 1:
在这个例子中，我们可以看到
- y_pred = [0，5，2，4] 作为我们可以选择的预测值。
- y_true = [0，1，2，3] 用作已经给定的真值。
- accuracy_score(y_true，y_pred) 用于检查真值和预测值的 accuracy_score。
import numpy as np
from sklearn.metrics import accuracy_score
y_pred = [0, 5, 2, 4]
y_true = [0, 1, 2, 3]
accuracy_score(y_true, y_pred)
输出:
运行上面的代码后，我们得到了下面的输出，我们可以看到这里的归一化值为真，由此我们得到了浮点值。
scikit learn accuracy score example
例 2:
在这个例子中，我们可以看到:
-
如果 normalize == False，则返回正确的置信度样本数(int)。
-
y_pred = [0，5，2，4] 作为我们可以选择的预测值。
-
y_true = [0，1，2，3] 用作已经给定的真值。
-
accuracy_score(y_true，y_pred，normalize=False) 用于检查真值和预测值的 accuracy_score。
import numpy as np
from sklearn.metrics import accuracy_score
y_pred = [0, 5, 2, 4]
y_true = [0, 1, 2, 3]
accuracy_score(y_true, y_pred)
accuracy_score(y_true, y_pred, normalize=False)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 true_value 和 predicted_value 的准确性得分。
scikit learn accuracy score normalize example
Read Scikit-learn Vs Tensorflow
scikit 如何学习 accuracy_score 的工作原理
sci kit learnaccuracy_score使用多标签分类，其中 accuracy _ score 函数计算子集准确度。
- 为样本预测的标签集必须与
y_true中的相应标签集完全匹配。 - 定义模型如何执行所有类的准确性。如果所有的类都同等重要，这是很有用的。
- 模型的准确性计算为正确预测数与预测总数之间的比率。
代码:
在下面的代码中，我们导入了两个库 import numpy 和 import sklearn.metrics ，用于预测模型的准确性。
- y_true = ["正"、"负"、"正"、"正"、"正"、"负"] 这是模型的真值。
- y_pred = ["正"，"负"，"正"，"正"，"负"，"正"，"正"]该模型的预测值。
- 精度= (r[0][0] + r[-1][-1]) / numpy。
sum(r)用于计算模型的精度 csore。 print(accuracy)用于在屏幕上打印 accuracy_score。
import numpy
import sklearn.metrics
y_true = ["positive", "negative", "negative", "positive", "positive", "positive", "negative"]
y_pred = ["positive", "negative", "positive", "positive", "negative", "positive", "positive"]
r = sklearn.metrics.confusion_matrix(y_true, y_pred)
r = numpy.flip(r)
accuracy = (r[0][0] + r[-1][-1]) / numpy.sum(r)
print(accuracy)
输出:
在运行上面的代码之后，我们得到了下面的输出，我们可以看到模型的准确度分数被打印在屏幕上。
How scikit learn accuracy score works
sklearn.metrics 有函数 accuracy_score() 可以用来计算准确度。
accuracy = sklearn.metrics.accuracy_score(y_true, y_pred)
您可能还喜欢:
因此，在本教程中，我们讨论了在 python 中的sci kit learn accuracy _ score，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- scikit 学习准确性 _ 分数
- scikit 学习准确性 _ 分数示例
- scikit 如何学习 accuracy_score 的工作原理
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习分类教程
在本Python 教程中，我们将学习scikit 如何学习分类，我们还将涵盖与 scikit 学习分类相关的不同例子。此外，我们将涵盖这些主题。
- Scikit 学习分类
- Scikit 学习分类报告
- Scikit 学习分类指标
- Scikit 学习分类示例
- Scikit 学习分类树
- Scikit 学习分类准确性
- Scikit 学习分类报告支持
目录
Scikit 学习分类
在本节中，我们将了解如何在 Python 中使用 Scikit 学习 分类的工作原理。
- 分类是一种数据分析形式，它提取描述重要数据类别的模型。
- 分类是一堆不同的类，并将这些类分成不同的类别。
代码:
在下面的代码中，我们将导入一些库，从中我们可以执行分类任务。
- ****中的x _ tra，x_test，y_train，y_test = train_test_split(x，y，test_size=0.4，random_state=42) 用于拆分训练和测试部分的数据。
- axis.scatter(x_train[:，0]，x_train[:，1]，c=y_train，cmap=cm_bright，edgecolors="k") 用于绘制训练点。
- x_test[:，0]，x_test[:，1]，c=y_test，cmap=cm_bright，alpha=0.6，edgecolors="k") 用于绘制测试点。
import numpy as num
import matplotlib.pyplot as plot
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
h = 0.02
name = [
"Nearest Neighbors",
"Linear SVM",
"RBF SVM",
"Gaussian Process",
"Decision Tree",
"Random Forest",
"Neural Net",
"AdaBoost",
"Naive Bayes",
"QDA",
]
classifier = [
KNeighborsClassifier(3),
SVC(kernel="linear", C=0.025),
SVC(gamma=2, C=1),
GaussianProcessClassifier(1.0 * RBF(1.0)),
DecisionTreeClassifier(max_depth=5),
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
MLPClassifier(alpha=1, max_iter=1000),
AdaBoostClassifier(),
GaussianNB(),
QuadraticDiscriminantAnalysis(),
]
x, y = make_classification(
n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1
)
rang = num.random.RandomState(2)
x += 2 * rang.uniform(size=x.shape)
linearly_separable = (x, y)
datasets = [
make_moons(noise=0.3, random_state=0),
make_circles(noise=0.2, factor=0.5, random_state=1),
linearly_separable,
]
figure = plot.figure(figsize=(27, 9))
i = 1
for ds_cnt, ds in enumerate(datasets):
x, y = ds
x = StandardScaler().fit_transform(x)
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=0.4, random_state=42
)
x_min, x_max = x[:, 0].min() - 0.5, x[:, 0].max() + 0.5
y_min, y_max = x[:, 1].min() - 0.5, x[:, 1].max() + 0.5
xx, yy = num.meshgrid(num.arange(x_min, x_max, h), num.arange(y_min, y_max, h))
cm = plot.cm.RdBu
cm_bright = ListedColormap(["pink", "green"])
axis = plot.subplot(len(datasets), len(classifier) + 1, i)
if ds_cnt == 0:
axis.set_title("Input data")
axis.scatter(x_train[:, 0], x_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="r")
axis.scatter(
x_test[:, 0], x_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6, edgecolors="r"
)
axis.set_xlim(xx.min(), xx.max())
axis.set_ylim(yy.min(), yy.max())
axis.set_xticks(())
axis.set_yticks(())
i += 1
for name, clf in zip(name, classifier):
axis = plot.subplot(len(datasets), len(classifier) + 1, i)
clf.fit(x_train, y_train)
score = clf.score(x_test, y_test)
if hasattr(clf, "decision_function"):
Z = clf.decision_function(num.c_[xx.ravel(), yy.ravel()])
else:
Z = clf.predict_proba(num.c_[xx.ravel(), yy.ravel()])[:, 1]
Z = Z.reshape(xx.shape)
axis.contourf(xx, yy, Z, cmap=cm, alpha=0.8)
axis.scatter(
x_train[:, 0], x_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="r"
)
axis.scatter(
x_test[:, 0],
x_test[:, 1],
c=y_test,
cmap=cm_bright,
edgecolors="r",
alpha=0.6,
)
axis.set_xlim(xx.min(), xx.max())
axis.set_ylim(yy.min(), yy.max())
axis.set_xticks(())
axis.set_yticks(())
if ds_cnt == 0:
axis.set_title(name)
axis.text(
xx.max() - 0.3,
yy.min() + 0.3,
("%.2f" % score).lstrip("0"),
size=15,
horizontalalignment="right",
)
i += 1
plot.tight_layout()
plot.show()
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到我们有一个不同的分类器，并且我们将这个分类分类到不同的类别中。
scikit learn classification
另外，检查: Scikit-learn 逻辑回归
Scikit 学习分类报告
在本节中，我们将了解sci kit 学习分类报告如何在 python 中工作。
分类报告是用于根据分类算法计算预测值的过程。
代码:
在下面的代码中，我们将从 sklearn.metrics 导入 classification_report，通过它我们可以计算分类算法的预测值。
- targetnames = ['Class 1 '，' Class 2 '，' Class 3'] 用作目标变量。
- 【打印(分类 _ 报告(y_true，y_pred，target_names=targetnames)) 用于打印分类的报告。
from sklearn.metrics import classification_report
y_true = [0, 1, 2, 2, 1]
y_pred = [0, 0, 2, 2, 1]
targetnames = ['Class 1', 'Class 2', 'Class 3']
print(classification_report(y_true, y_pred, target_names=targetnames))
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上打印了分类报告。
scikit learn classification report
阅读: Scikit 学习决策树
Scikit 学习分类指标
在这一节中，我们将学习scikit 如何在 python 中学习分类指标。
- 分类度量是需要正面类别的概率评估的过程。
sklearn.metrics是实现分数、概率函数来计算分类性能的函数。
代码:
在下面的代码中，我们将从 sklearn.metrics 导入 fbeta_score，make_scorer，通过它需要正类的概率评估。
- scores = make _ scorer(mycustomlossfunc，greater_is_better=False) 用于计算得分函数。
- classifier = classifier.fit(x，y) 用于拟合分类器。
from sklearn.metrics import fbeta_score, make_scorer
ftwoscorer = make_scorer(fbeta_score, beta=2)
from sklearn.model_selection import GridSearchCV
from sklearn.svm import LinearSVC
Grid = GridSearchCV(LinearSVC(), param_grid={'C': [1, 10]},
scoring=ftwoscorer, cv=5)
import numpy as num
def mycustomlossfunc(y_true, y_pred):
differ = num.abs(y_true - y_pred).max()
return num.log1p(differ)
scores = make_scorer(mycustomlossfunc, greater_is_better=False)
x = [[1], [0]]
y = [0, 1]
from sklearn.dummy import DummyClassifier
classifier = DummyClassifier(strategy='most_frequent', random_state=0)
classifier = classifier.fit(x, y)
mycustomlossfunc(y, classifier.predict(x))
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到一个损失函数打印在屏幕上。
scikit learn classification metrics
阅读: Scikit 学习层次聚类
Scikit 学习分类示例
在本节中，我们将学习 python 中的 scikit 学习分类示例。
分类是一种数据分析形式，它提取描述重要数据类别的模型。
代码:
在下面的代码中，我们将从 sklearn.gaussian_process 导入 gaussianProcessClassifier，还将导入 matplotlib.pyplot 作为我们绘制概率类的 plot 。
iris = datasets . load _ iris()用于加载 iris 数据集。- x = iris.data[:，0:2] 用于只取前两个特征进行可视化。
- plot.figure(figsize=(3 * 2，nclassifiers * 2)) 用于在屏幕上绘制图形。
probe = classifier . predict _ proba(xfull)用于查看概率。- axis = plot.axes([0.16，0.05，0.8，0.06]) 用于在图形上绘制坐标轴。
- plot.title("类的概率")用来给图加标题。
import matplotlib.pyplot as plot
import numpy as num
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn import datasets
iris = datasets.load_iris()
x = iris.data[:, 0:2]
y = iris.target
nfeatures = x.shape[1]
c = 10
kernel = 1.0 * RBF([1.0, 1.0])
classifier = {
"L1 logistic": LogisticRegression(
C=c, penalty="l1", solver="saga", multi_class="multinomial", max_iter=10000
),
"L2 logistic (Multinomial)": LogisticRegression(
C=c, penalty="l2", solver="saga", multi_class="multinomial", max_iter=10000
),
"L2 logistic (OvR)": LogisticRegression(
C=c, penalty="l2", solver="saga", multi_class="ovr", max_iter=10000
),
"Linear SVC": SVC(kernel="linear", C=c, probability=True, random_state=0),
"GPC": GaussianProcessClassifier(kernel),
}
nclassifiers = len(classifiers)
plot.figure(figsize=(3 * 2, nclassifiers * 2))
plot.subplots_adjust(bottom=0.2, top=0.95)
xx = num.linspace(3, 9, 100)
yy = num.linspace(1, 5, 100).T
xx, yy = num.meshgrid(xx, yy)
xfull = num.c_[xx.ravel(), yy.ravel()]
for index, (name, classifier) in enumerate(classifiers.items()):
classifier.fit(x, y)
y_predict = classifier.predict(x)
accuracy = accuracy_score(y, y_predict)
print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
probab = classifier.predict_proba(xfull)
nclasses = num.unique(y_pred).size
for k in range(nclasses):
plot.subplot(nclassifiers, nclasses, index * nclasses + k + 1)
plot.title("Class %d" % k)
if k == 0:
plot.ylabel(name)
imshowhandle = plot.imshow(
probab[:, k].reshape((100, 100)), extent=(3, 9, 1, 5), origin="lower"
)
plot.xticks(())
plot.yticks(())
idx = y_pred == k
if idx.any():
plot.scatter(x[idx, 0], x[idx, 1], marker="o", c="b", edgecolor="r")
axis = plot.axes([0.16, 0.05, 0.8, 0.06])
plot.title("Probability of classes")
plot.colorbar(imshowhandle, cax=axis, orientation="horizontal")
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到模型的准确性和概率显示在屏幕上。
scikit learn classification example
阅读: Scikit 学习随机森林
Scikit 学习分类树
在这一节中，我们将了解 scikit 如何在 python 中学习分类树。
分类树是一种监督学习方法。该功能旨在创建一个模型，通过该模型预测目标变量。
代码:
在下面的代码中，我们将从 sklearn.model_selection 中导入 cross_val_score，通过它我们可以计算交叉值得分。
classifier = decision tree classifier(random _ state = 1)用于创建模型并预测目标值。- cross_val_score(classifier，iris.data，iris.target，cv=20) 用于计算交叉值得分。
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier(random_state=1)
iris = load_iris()
cross_val_score(classifier, iris.data, iris.target, cv=20)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉值得分被打印在屏幕上。
scikit learn classification tree
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习分类精度
在这一节中，我们将了解sci kit 如何学习分类精度在 python 中的工作原理。
- 分类是一个有一堆类别的过程，这些类别被分为不同的类别。
- 分类的准确性定义为预测总数中正确预测的数量。
代码:
在下面的代码中，我们将从 sklearn.metrics 导入 accuracy_score，它实现 score、probability 函数来计算分类性能。
accuracy_score(ytrue，ypred) 用于计算准确度分数。
from sklearn.metrics import accuracy_score
ypred = [0, 1, 2, 3]
ytrue = [0, 3, 2, 1]
accuracy_score(ytrue, ypred)
输出:
运行上面的代码后，我们得到了下面的输出，我们可以看到屏幕上显示了准确度分数。
scikit learn classification accuracy
关于 accuracy_score 的详细信息，请查看以下教程:Scikit learn accuracy _ score。
Scikit 学习分类报告支持
在本节中，我们将了解sci kit 学习分类报告支持如何在 python 中工作。
正如我们所知，分类报告用于计算预测的价值，支持度定义为放置在给定类别中的真实反应的样本数。
代码:
- 在下面的代码中，我们将从 sklearn.metrics 导入 precision _ recall _ fs core _ support，通过它打印真实的响应。
- precision _ recall _ fs core _ support(y _ true，y_pred，average='micro') 用于在屏幕上打印报告支持得分。
import numpy as num
from sklearn.metrics import precision_recall_fscore_support
y_true = num.array(['rat', 'cat', 'rat', 'bat', 'rat', 'cat'])
y_pred = num.array(['rat', 'rat', 'bat', 'cat', 'bat', 'bat'])
precision_recall_fscore_support(y_true, y_pred, average='micro')
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上打印了报告支持得分。
scikit learn classification report support
另外，看看 Scikit learn 上的更多文章。
因此，在本教程中，我们讨论了 scikit learn 分类，并且我们还涵盖了与其实现相关的不同示例。这里是我们已经介绍过的的例子列表。
- Scikit 学习分类
- Scikit 学习分类报告
- Scikit 学习分类指标
- Scikit 学习分类示例
- Scikit 学习分类树
- Scikit 学习分类准确性
- Scikit 学习分类报告支持
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习混淆矩阵
在这个 Python 教程中，我们将学习sci kit 学习混淆矩阵如何在 Python 中工作，我们还将涵盖与 Scikit 学习混淆矩阵相关的不同示例。我们将讨论这些话题。
- Scikit 学习混淆矩阵
- Scikit 学习混淆矩阵示例
- Scikit 学习混淆矩阵图
- Scikit 学习混淆矩阵准确性
- Scikit 学习混淆矩阵多类
- Scikit 学习混淆矩阵显示
- Scikit 学习混淆矩阵标签
- Scikit 学习混淆矩阵标准化
目录
- Scikit 学习混淆矩阵
- Scikit 学习混淆矩阵示例
- Scikit 学习混淆矩阵图
- Scikit 学习混淆矩阵准确度
- Scikit 学习混淆矩阵多类
- Scikit 学习混淆矩阵显示
- Scikit 学习混淆矩阵标签
- Scikit 学习混淆矩阵归一化
Scikit 学习混淆矩阵
在本节中，我们将了解sci kit 学习混淆矩阵如何在 python 中工作。
- Scikit learn 混淆矩阵被定义为一种计算分类性能的技术。
- 混淆矩阵也用于预测或总结分类问题的结果。
代码:
- y_true = [2，0，0，2，0，1] 用于获取真值。
- y_pred = [0，0，2，0，0，2] 用于得到预测值。
- 混淆矩阵(y_true，y_pred) 用于评估混淆矩阵。
from sklearn.metrics import confusion_matrix
y_true = [2, 0, 0, 2, 0, 1]
y_pred = [0, 0, 2, 0, 0, 2]
confusion_matrix(y_true, y_pred)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到混淆矩阵值被打印在屏幕上。
Scikit learn confusion matrix
阅读: Scikit 学习图像处理
Scikit 学习混淆矩阵示例
在本节中，我们将了解Scikit 如何学习混淆矩阵示例在 python 中工作。
- Scikit 学习混淆矩阵示例被定义为总结分类结果的技术。
- 混淆矩阵还预测了分类模型的正确和错误预测的数量。
代码:
在下面的代码中，我们将导入一些库，从中我们可以制作混淆矩阵。
iris = datasets . load _ iris()用于加载虹膜数据。class _ names = iris . target _ names用于获取目标名称。- x_train，x_test，y_train，y_test = train_test_split(x，y，random_state=0) 用于将数据集拆分为训练和测试数据。
- 分类器= svm。SVC(kernel="linear "，C=0.02)。fit(x _ train，y_train)用于拟合模型。
confusionmatrix display . from _ estimator()用于绘制混淆矩阵。print(display . confusion _ matrix)用于打印混淆矩阵。
import numpy as num
import matplotlib.pyplot as plot
from sklearn import svm, datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import ConfusionMatrixDisplay
iris = datasets.load_iris()
x = iris.data
y = iris.target
class_names = iris.target_names
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)
classifier = svm.SVC(kernel="linear", C=0.02).fit(x_train, y_train)
num.set_printoptions(precision=2)
title_options = [
("Confusion matrix, without normalization", None),
("Normalized confusion matrix", "true"),
]
for title, normalize in title_options:
display = ConfusionMatrixDisplay.from_estimator(
classifier,
x_test,
y_test,
display_labels=class_names,
cmap=plot.cm.Blues,
normalize=normalize,
)
display.ax_.set_title(title)
print(title)
print(display.confusion_matrix)
plot.show()
输出:
在下面的输出中，我们可以看到分类的结果在混淆矩阵的帮助下总结在屏幕上。
Scikit learn confusion matrix example
Scikit 学习混淆矩阵图
在本节中，我们将了解 Scikit 如何在 python 中学习混淆矩阵图。
- Scikit 学习混淆矩阵图用于在屏幕上绘制图形，以总结模型的结果。
- 它用于绘制图表，以预测模型的正确或错误预测数。
代码:
在下面的代码中，我们将导入一些库，从中我们可以在屏幕上绘制混淆矩阵。
- x，y = make _ class ification(random _ state = 0)用于进行分类。
- x_train，x_test，y_train，y_test = train_test_split(x，y，random_state=0) 用于将数据集拆分为训练集和测试集。
- classifier.fit(x_train，y_train) 用于拟合模型。
- 绘制混淆矩阵(分类器，x_test，y_test) 用于在屏幕上绘制混淆矩阵。
import matplotlib.pyplot as plot
from sklearn.datasets import make_classification
from sklearn.metrics import plot_confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
x, y = make_classification(random_state=0)
x_train, x_test, y_train, y_test = train_test_split(
x, y, random_state=0)
classifier = SVC(random_state=0)
classifier.fit(x_train, y_train)
SVC(random_state=0)
plot_confusion_matrix(classifier, x_test, y_test)
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上绘制的混淆矩阵。
Scikit learn confusion matrix plot
阅读: Scikit 学习 KNN 教程
Scikit 学习混淆矩阵准确度
在本节中，我们将了解 python 中模型的 Scikit learn 混淆矩阵精度。
Scikit learn 混淆矩阵精度用于计算矩阵的精度我们的模型结果有多精确。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算模型的精度。
- y_pred = [1，3，2，0] 用于预测预测值。
- y_true = [0，1，2，3] 用于预测真值。
- accuracy_score(y_true，y_pred) 用于预测准确率得分。
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
y_pred = [1, 3, 2, 0]
y_true = [0, 1, 2, 3]
accuracy_score(y_true, y_pred)
accuracy_score(y_true, y_pred, normalize=False)
import numpy as num
accuracy_score(num.array([[0, 1], [1, 1]]), num.ones((2, 2)))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上打印了混淆矩阵准确度分数。
Scikit learn confusion matrix accuracy
阅读: Scikit 学习情绪分析
Scikit 学习混淆矩阵多类
在这一节中，我们将学习scikit 如何在 python 中学习混淆矩阵多类工作。
Scikit 学习混淆矩阵多类被定义为对三个或更多类中的一个进行分类的问题。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建一个混淆矩阵多类。
df = PD . read _ CSV(" iris . CSV ")用于加载数据集。df.dtypes用于选择数据的类型。
**#importing packages**
import pandas as pds
import numpy as num
import seaborn as sb
import matplotlib.pyplot as plot
df = pd.read_csv("IRIS.csv")
df.head()
df.dtypes
Scikit learn confusion matrix multi-class dataset
- x = df.drop(['species']，axis=1) 用于分离自变量和因变量。
print(x.shape)用于打印数据集的形状。
**#Separating independant variable and dependent variable("Species")**
x = df.drop(['species'], axis=1)
y = df['species']
print(x.shape)
print(y.shape)
scikit learn confusion matrix multiclass separating dependent or independent variable
- x_train，x_test，y_train，y_test = train_test_split(x，y，test_
size=0.3，random_state=0) 用于将数据集拆分为训练集和测试集。 print(x_train.shape)用于打印列车组的形状。print(x_test.shape)用于打印测试集的形状。
**# Splitting the dataset to Train and test**
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0)
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)
Scikit learn confusion matrix multi-class train test data split
- 分类器= SVC(内核= '线性')。fit(x_train，y_train) 用于从 x 训练和 y 训练中训练分类器。
- cm =混淆矩阵(y_test，y_pred) 用于创建混淆矩阵。
- cm_df = pd。DataFrame() 用于创建数据帧。
- plot.figure(figsize=(5，4)) 用于绘制图形。
from sklearn.svm import SVC
from sklearn.metrics import confusion_matrix
classifier = SVC(kernel = 'linear').fit(x_train,y_train)
classifier.predict(x_train)
y_pred = classifier.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
cm_df = pd.DataFrame(cm,
index = ['SETOSA','VERSICOLR','VIRGINICA'],
columns = ['SETOSA','VERSICOLR','VIRGINICA'])
plot.figure(figsize=(5,4))
sb.heatmap(cm_df, annot=True)
plot.title('Confusion Matrix')
plot.ylabel('Actal Values')
plot.xlabel('Predicted Values')
plot.show()
Scikit learn confusion matrix multiclass
阅读: Scikit 学习梯度下降
Scikit 学习混淆矩阵显示
在本节中，我们将了解 Scikit 如何在 python 中学习混淆矩阵显示。
Scikit 学习混淆矩阵显示被定义为一个矩阵，其中 I，j 等于一个组中预测的观察次数。
代码:
在下面的代码中，我们将学习导入一些库，从中我们可以看到混淆矩阵是如何在屏幕上显示的。
- x，y = make _ class ification(random _ state = 0)用于进行分类。
- x_train，x_test，y_train，y_test = train_test_split(x，y，random_state=0) 用于将数据集拆分为训练和测试数据。
- classifier.fit(x_train，y_train) 用于拟合数据。
- predictions = classifier . predict(x _ test)用于预测数据。
- display = confusionmatrix display(confusion _ matrix = cm，display _ labels = classifier . classes _)用于显示混淆矩阵。
display.plot()用于绘制矩阵。
import matplotlib.pyplot as plot
from sklearn.datasets import make_classification
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
x, y = make_classification(random_state=0)
x_train, x_test, y_train, y_test = train_test_split(x, y,
random_state=0)
classifier = SVC(random_state=0)
classifier.fit(x_train, y_train)
SVC(random_state=0)
predictions = classifier.predict(x_test)
cm = confusion_matrix(y_test, predictions, labels=classifier.classes_)
display = ConfusionMatrixDisplay(confusion_matrix=cm,
display_labels=classifier.classes_)
display.plot()
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上显示了一个混淆矩阵。
Scikit learn confusion matrix display
阅读: Scikit 学习分类教程
Scikit 学习混淆矩阵标签
在本节中，我们将学习Scikit 如何在 python 中学习混淆矩阵标签。
Scikit 学习混淆矩阵标签被定义为二维阵列，其将预测的标签组与真实标签进行对比。
代码:
在下面的代码中，我们将导入一些库来了解 scikit 学习混淆矩阵标签是如何工作的。
- y_true = num.array([[1，0，0]，[0，1，1]]) 用于收集数组中的真标签。
- y_pred = num.array([[1，0，1]，[0，1，0]]) 用于收集数组中的预测标签。
- 多标签混淆矩阵(y_true，y_pred) 用于得到多标签混淆矩阵。
import numpy as num
from sklearn.metrics import multilabel_confusion_matrix
y_true = num.array([[1, 0, 0],
[0, 1, 1]])
y_pred = num.array([[1, 0, 1],
[0, 1, 0]])
multilabel_confusion_matrix(y_true, y_pred)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到混淆矩阵标签打印在屏幕上。
Scikit learn confusion matrix labels
阅读: Scikit 学习超参数调整
Scikit 学习混淆矩阵归一化
在本节中，我们将了解sci kit 如何学习混淆矩阵规范化在 python 中的工作方式。
Scikit 学习混淆矩阵标准化被定义为代表每组中存在一个样本的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以规范化矩阵。
iris = datasets . load _ iris()用于加载数据。- x_train，x_test，y_train，y_test = train_test_split(X，y，random_state=0) 用于将数据集拆分为训练和测试数据。
- 分类器= svm。SVC(kernel='linear '，C=0.01) 用作分类器。
- y _ pred = classifier . fit(x _ train，y_train)。【T1 预测(x_test)】用于拟合模型。
- cm =混淆矩阵(y_true，y_pred) 用于计算混淆矩阵。
- classes = classes[unique _ labels(y _ true，y_pred)] 用于数据中出现的标签。
- 图，axis = plot.subplots() 用于在屏幕上绘制图。
- plot . setp(axis . get _ xticklabels()，rotation=45，ha="right "，rotation_mode="anchor") 用于设置对齐和旋转刻度。
- plot _ confusion _ matrix(y _ test，y_pred，classes=class_names，normalize=True，title= '归一化混淆矩阵')用于绘制归一化混淆矩阵。
import numpy as num
import matplotlib.pyplot as plot
from sklearn import svm, datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from sklearn.utils.multiclass import unique_labels
iris = datasets.load_iris()
x_digits = iris.data
y = iris.target
class_names = iris.target_names
x_train, x_test, y_train, y_test = train_test_split(X, y, random_state=0)
classifier = svm.SVC(kernel='linear', C=0.01)
y_pred = classifier.fit(x_train, y_train).predict(x_test)
def plot_confusion_matrix(y_true, y_pred, classes,
normalize=False,
title=None,
cmap=plot.cm.Blues):
if not title:
if normalize:
title = 'Normalized confusion matrix'
cm = confusion_matrix(y_true, y_pred)
classes = classes[unique_labels(y_true, y_pred)]
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, num.newaxis]
print("Normalized confusion matrix")
print(cm)
figure, axis = plot.subplots()
im = axis.imshow(cm, interpolation='nearest', cmap=cmap)
axis.figure.colorbar(im, ax=axis)
axis.set(xticks=num.arange(cm.shape[1]),
yticks=num.arange(cm.shape[0]),
xticklabels=classes, yticklabels=classes,
title=title,
ylabel='True label',
xlabel='Predicted label')
plot.setp(axis.get_xticklabels(), rotation=45, ha="right",
rotation_mode="anchor")
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
axis.text(j, i, format(cm[i, j], fmt),
ha="center", va="center",
color="cyan" if cm[i, j] > thresh else "red")
figure.tight_layout()
return axis
plot_confusion_matrix(y_test, y_pred, classes=class_names, normalize=True,
title='Normalized confusion matrix')
plot.show()
输出:
在下面的代码中，我们将看到一个标准化的混淆矩阵数组被创建，并且一个标准化的混淆矩阵图被绘制在屏幕上。
Scikit learn confusion matrix normalized
另外，看看更多的 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit learn 混淆矩阵，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习混淆矩阵
- Scikit 学习混淆矩阵示例
- Scikit 学习混淆矩阵图
- Scikit 学习混淆矩阵准确性
- Scikit 学习混淆矩阵多类
- Scikit 学习混淆矩阵显示
- Scikit 学习混淆矩阵标签
- Scikit 学习混淆矩阵标准化
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit learn 交叉验证[实用指南]
在这个 Python 教程中，我们将学习Scikit learn 交叉验证如何在 Python 中工作，我们还将涵盖与 Scikit learn 交叉验证相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习交叉验证
- Scikit 学习交叉验证分数
- Scikit 学习交叉验证套索
- Scikit 学习交叉验证预测
- Scikit 学习交叉验证时间序列
- Scikit 学习交叉验证分离
- Scikit 学习交叉验证混淆矩阵
- Scikit 学习交叉验证超参数
- Scikit 学习交叉验证混洗
- Scikit 学习交叉验证网格搜索
目录
- Scikit 学习交叉验证
- Scikit 学习交叉验证分数
- Scikit 学习交叉验证套索
- Scikit 学习交叉验证预测
- Scikit 学习交叉验证时间序列
- Scikit 学习交叉验证分割
- Scikit 学习交叉验证混淆矩阵
- Scikit 学习交叉验证超参数
- Scikit 学习交叉验证洗牌
- Scikit 学习交叉验证网格搜索
Scikit 学习交叉验证
在本节中，我们将了解 python 中的 Scikit learn 交叉验证工作原理。
交叉验证被定义为一个过程，在该过程中，我们使用数据集训练我们的模型，然后使用支持数据集进行评估。
代码:
在下面的代码中，我们将导入一些库，我们将从这些库中训练我们的模型并对其进行评估。
- x，y = datasets . load _ iris(return _ X _ y = True)用于加载数据集。
- x_train，x_test，y_train，y_test = train_test_split(x，y，test_size=0.4，random_state=0) 用于将数据集拆分为训练数据和测试数据。
- x_train.shape，y_train.shape 用于评估列车模型的形状。
- 分类器= svm。SVC(内核= '线性'，C=1)。fit(x _ train，y_train)用于拟合模型。
- scores = cross _ val _ score(classifier，x，y，cv=7) 用于计算交叉值得分。
import numpy as num
from sklearn.model_selection import train_test_split
from sklearn import datasets
from sklearn import svm
x, y = datasets.load_iris(return_X_y=True)
x.shape, y.shape
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=0.4, random_state=0)
x_train.shape, y_train.shape
x_test.shape, y_test.shape
classifier = svm.SVC(kernel='linear', C=1).fit(x_train, y_train)
classifier.score(x_test, y_test)
from sklearn.model_selection import cross_val_score
classifier = svm.SVC(kernel='linear', C=1, random_state=42)
scores = cross_val_score(classifier, x, y, cv=7)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到交叉验证指标得分以数组的形式打印在屏幕上。
Scikit learn cross-validation
Read: Scikit-learn Vs Tensorflow
Scikit 学习交叉验证分数
在本节中，我们将了解 Scikit 如何在 python 中学习交叉验证分数。
交叉验证分数定义为估计新数据的模型能力并计算数据分数的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算交叉验证分数。
diabetes = datasets . load _ diabetes()用于加载数据。- x = diabetes.data[:170] 用于计算糖尿病数据。
- print(cross_val_score(lasso，x，y，cv=5)) 用于在屏幕上打印分数。
from sklearn import datasets, linear_model
from sklearn.model_selection import cross_val_score
diabetes = datasets.load_diabetes()
x = diabetes.data[:170]
y = diabetes.target[:170]
lasso = linear_model.Lasso()
print(cross_val_score(lasso, x, y, cv=5))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉验证分数被打印在屏幕上。
Scikit learn cross-validation score
阅读: Scikit 学习决策树
Scikit 学习交叉验证套索
在本节中，我们将了解 Scikit 如何在 python 中学习交叉验证套索的工作原理。
Lasso 代表最小绝对收缩和选择器运算符，用于确定惩罚项的权重。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算交叉验证 lasso 得分。
- x，y = make_regression(noise=5，random_state=0) 用于进行或生成回归。
- 回归= LassoCV(cv=7，random_state=0)。fit(x，y)用于拟合套索模型。
- regression.score(x，y) 用于计算 lasso 得分。
from sklearn.linear_model import LassoCV
from sklearn.datasets import make_regression
x, y = make_regression(noise=5, random_state=0)
regression = LassoCV(cv=7, random_state=0).fit(x, y)
regression.score(x, y)
输出:
在下面的输出中，我们可以看到 lasso 分数被计算出来，结果被打印在屏幕上。
Scikit learn cross-validation lasso score
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习交叉验证预测
在这一节中，我们将了解 Scikit learn 交叉验证预测如何在 python 中工作。
- Scikit learn 交叉验证预测方法用于通过可视化来预测误差。
- 交叉验证用于评估数据，并使用数据的不同部分来训练和测试模型。
代码:
在下面的代码中，我们将导入一些库，从中我们可以通过交叉验证来评估预测。
- x，y = datasets . load _ diabetes(return _ X _ y = True)用于加载数据集。
- predict = cross _ val _ predict(linear model，x，y，cv=10) 用于预测模型，返回相同大小的数组。
- fig，axis = plot.subplots() 用于在屏幕上绘制图形。
- axis.scatter(y，predict，edgecolors=(0，0，0)) 用于在图形上绘制散点图。
- axis.plot([y.min()，y.max()]，[y.min()，y.max()]，" b-"，lw=6) 用于在图形上绘制轴。
axis . set _ xlabel(" Measured ")用于在图形上绘制 x 标签。axis . set _ y label(" Predicted ")用于在图形上绘制 y 标签。
from sklearn import datasets
from sklearn.model_selection import cross_val_predict
from sklearn import linear_model
import matplotlib.pyplot as plot
linearmodel = linear_model.LinearRegression()
x, y = datasets.load_diabetes(return_X_y=True)
predict = cross_val_predict(linearmodel,x, y, cv=10)
fig, axis = plot.subplots()
axis.scatter(y, predict, edgecolors=(0, 0, 0))
axis.plot([y.min(), y.max()], [y.min(), y.max()], "b--", lw=6)
axis.set_xlabel("Measured")
axis.set_ylabel("Predicted")
plot.show()
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到在屏幕上绘制了带有交叉验证预测的图形。
scikit learn cross-validation predict
阅读: Scikit 学习层次聚类
Scikit 学习交叉验证时间序列
在这一节中，我们将了解Scikit 如何在 python 中学习交叉验证时序工作。
- Scikit learn crossvalidation 时间序列被定义为由单个观察值组成的一系列测试集。
- 训练集只包括在时间上早于形成测试集观测值的观测值。
- 在时间序列交叉验证中，在构建预测时不考虑未来的观测值。
代码:
在下面的代码中，我们将导入一些库，从中我们可以看到如何通过时间序列分割数据。
- x = num.array([[1，2]，[3，4]，[1，2]，[3，4]，[1，2]，[3，4]]) 用于给 x 赋值。
- y = num.array([1，2，3，4，5，6]) 用于给 y 赋值。
print(timeseriscv)用于打印时间序列交叉验证数据。- x = num . randn(12，2) 用于将 12 个样本的测试规模固定为 2。
- print("TRAIN:"，train_index，" TEST:"，test_index) 用于打印训练和测试数据。
import numpy as num
from sklearn.model_selection import TimeSeriesSplit
x = num.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
y = num.array([1, 2, 3, 4, 5, 6])
timeseriescv = TimeSeriesSplit()
print(timeseriescv)
for train_index, test_index in timeseriescv.split(x):
print("TRAIN:", train_index, "TEST:", test_index)
x_train, x_test = x[train_index], x[test_index]
y_train, y_test = y[train_index], y[test_index]
x = num.random.randn(12, 2)
y = num.random.randint(0, 2, 12)
timeseriescv = TimeSeriesSplit(n_splits=3, test_size=2)
for train_index, test_index in tscv.split(x):
print("TRAIN:", train_index, "TEST:", test_index)
x_train, x_test = x[train_index], x[test_index]
y_train, y_test = y[train_index], y[test_index]
输出:
在下面的输出中，我们可以看到训练和测试数据被时间序列交叉验证分割。
Scikit learn cross-validation time series
阅读: Scikit 学习岭回归
Scikit 学习交叉验证分割
在本节中，我们将了解Scikit 如何在 python 中学习交叉验证分割。
- 交叉验证被定义为用于评估有限数据样本上的模型的过程。
- 交叉验证数据可以用一个称为 k 的参数分成许多组。
代码:
在下面的代码中，我们将导入一些库，从这些库中模型可以被分成许多组。
num.random.seed(1338)用于生成随机数。n_splits = 6用于拆分数据。- percentiles_classes = [0.1，0.3，0.6] 用于生成类数据。
- groups = num . h stack([[ii] 10 for ii in range(10)])*用于平均分割组
- fig，axis = plot.subplots() 用于绘制图形。
axis.scatter()用于绘制散点图。- axis.set_title("{} ")。格式(类型(cv))。name)，fontsize=15) 用来给图形加标题。
from sklearn.model_selection import (
TimeSeriesSplit,
KFold,
ShuffleSplit,
StratifiedKFold,
GroupShuffleSplit,
GroupKFold,
StratifiedShuffleSplit,
StratifiedGroupKFold,
)
import numpy as num
import matplotlib.pyplot as plot
from matplotlib.patches import Patch
num.random.seed(1338)
cmapdata = plot.cm.Paired
cmapcv = plot.cm.coolwarm
n_splits = 6
n_points = 100
x = num.random.randn(100, 10)
percentiles_classes = [0.1, 0.3, 0.6]
y = num.hstack([[ii] * int(100 * perc) for ii, perc in enumerate(percentiles_classes)])
groups = num.hstack([[ii] * 10 for ii in range(10)])
def visualize_groups(classes, groups, name):
# Visualize dataset groups
fig, axis = plot.subplots()
axis.scatter(
range(len(groups)),
[0.5] * len(groups),
c=groups,
marker="_",
lw=50,
cmap=cmapdata,
)
axis.scatter(
range(len(groups)),
[3.5] * len(groups),
c=classes,
marker="_",
lw=50,
cmap=cmapdata,
)
axis.set(
ylim=[-1, 5],
yticks=[0.5, 3.5],
yticklabels=["Data\ngroup", "Data\nclass"],
xlabel="Sample index",
)
visualize_groups(y, groups, "nogroups")
def plot_cv_indices(cv, x, y, group, ax, n_splits, lw=10):
"""Create a sample plot for indices of a cross-validation object."""
**# Generate the training/testing visualizations for each CV split
for ii, (tr, tt) in enumerate(cv.split(X=x, y=y, groups=group)):**
**# Fill in indices with the training/test groups**
indices = np.array([np.nan] * len(x))
indices[tt] = 1
indices[tr] = 0
** # Visualize the results**
axis.scatter(
range(len(indices)),
[ii + 0.5] * len(indices),
c=indices,
marker="_",
lw=lw,
cmap=cmapcv,
vmin=-0.2,
vmax=1.2,
)
axis.scatter(
range(len(x)), [ii + 1.5] * len(x), c=y, marker="_", lw=lw, cmap=cmapdata
)
axis.scatter(
range(len(x)), [ii + 2.5] * len(x), c=group, marker="_", lw=lw, cmap=cmapdata
)
**# Formatting**
yticklabels = list(range(n_splits)) + ["class", "group"]
axis.set(
yticks=np.arange(n_splits + 2) + 0.5,
yticklabels=yticklabels,
xlabel="Sample index",
ylabel="CV iteration",
ylim=[n_splits + 2.2, -0.2],
xlim=[0, 100],
)
axis.set_title("{}".format(type(cv).__name__), fontsize=15)
return axis
fig, axis = plot.subplots()
cv = KFold(n_splits)
plot_cv_indices(cv, x, y, groups, axis, n_splits)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上显示了 scikit learn 交叉验证分割。
scikit learn cross-validation split
阅读: Scikit 学习功能选择
Scikit 学习交叉验证混淆矩阵
在本节中，我们将了解 Scikit learn 交叉验证矩阵如何在 python 中工作。
交叉验证混淆矩阵被定义为一个评估矩阵，从中我们可以估计模型的性能。
代码:
在下面的代码中，我们将导入一些库，从中我们可以评估模型性能。
iris = datasets . load _ iris()用于加载虹膜数据。- 打印(虹膜。【描述】(T1)用于打印虹膜数据。
- predicted _ targets = num . array([])用于预测目标值模型。
- actual _ targets = num . array([])用于获取实际目标值。
- 分类器= svm。SVC()。fit(train _ x，train_y)用于拟合分类器。
predicted _ labels = classifiers . predict(test _ x)用于预测测试集的标签。
import matplotlib.pyplot as plot
import numpy as num
from sklearn import svm, datasets
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import KFold
iris = datasets.load_iris()
data = iris.data
target = iris.target
classnames = iris.target_names
classnames
labels, counts = num.unique(target, return_counts=True)
print(iris.DESCR)
def evaluate_model(data_x, data_y):
k_fold = KFold(10, shuffle=True, random_state=1)
predicted_targets = num.array([])
actual_targets = num.array([])
for train_ix, test_ix in k_fold.split(data_x):
train_x, train_y, test_x, test_y = data_x[train_ix], data_y[train_ix], data_x[test_ix], data_y[test_ix]
classifiers = svm.SVC().fit(train_x, train_y)
predicted_labels = classifiers.predict(test_x)
predicted_targets = num.append(predicted_targets, predicted_labels)
actual_targets = num.append(actual_targets, test_y)
return predicted_targets, actual_targets
scikit learn cross-validation confusion matrix data
在这部分代码中，我们将生成规范化的混淆矩阵。
- plot.imshow(cnf_matrix，interpolation='nearest '，cmap=plt.get_cmap('Blues')) 用于绘制矩阵。
- plot.title(标题)用于在图形上绘制标题。
- plot.xticks(tick_marks，classes，rotation=45) 用于绘制 x 刻度。
- plot.ylabel('真实标签')用于在图形上绘制标签。
- plot.xlabel('预测标签')用于在图形上绘制 x 标签。
- plot _ confusion _ matrix(predicted _ target，actual_target) 用于在屏幕上绘制混淆矩阵。
def plot_confusion_matrix(predicted_labels_list, y_test_list):
cnf_matrix = confusion_matrix(y_test_list, predicted_labels_list)
num.set_printoptions(precision=2)
plot.figure()
generate_confusion_matrix(cnf_matrix, classes=class_names, normalize=True, title='Normalized confusion matrix')
plot.show()
def generate_confusion_matrix(cnf_matrix, classes, normalize=False, title='Confusion matrix'):
if normalize:
cnf_matrix = cnf_matrix.astype('float') / cnf_matrix.sum(axis=1)[:, num.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normalization')
plot.imshow(cnf_matrix, interpolation='nearest', cmap=plt.get_cmap('Blues'))
plot.title(title)
plot.colorbar()
tick_marks = np.arange(len(classes))
plot.xticks(tick_marks, classes, rotation=45)
plot.yticks(tick_marks, classes)
fmt = '.2f' if normalize else 'd'
thresh = cnf_matrix.max() / 2.
for i, j in itertools.product(range(cnf_matrix.shape[0]), range(cnf_matrix.shape[1])):
plot.text(j, i, format(cnf_matrix[i, j], fmt), horizontalalignment="center",
color="black" if cnf_matrix[i, j] > thresh else "blue")
plot.tight_layout()
plot.ylabel('True label')
plot.xlabel('Predicted label')
return cnf_matrix
predicted_target, actual_target = evaluate_model(data, target)
plot_confusion_matrix(predicted_target, actual_target)
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制的混淆矩阵，
scikit learn cross-validation confusion matrix
阅读: Scikit 学习线性回归+例题
Scikit 学习交叉验证超参数
在本节中，我们将了解 Scikit learn 交叉验证超参数在 python 中的工作原理。
交叉验证超参数定义为用于搜索理想模型架构的过程，也用于评估模型的性能。
代码:
在下面的代码中，我们将导入一些库，从中我们可以搜索理想的模型架构。
- paramgrid = {'max_depth': [4，5，10]，' min_samples_split': [3，5，10]} 用于定义 paramgrid。
- x，y = make _ class ification(n _ samples = 1000，random_state=0) 用于进行分类。
- base _ estimator = SVC(gamma = ' scale ')用于定义基本估计量。
- sh = halvinggridsearchv(base _ estimator，paramgrid，cv=5，factor=2，max_resources=40，aggressive_elimination=True，)。fit(x，y)用于拟合模型。
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV
import pandas as pd
paramgrid = {'max_depth': [4, 5, 10],
'min_samples_split': [3, 5, 10]}
base_estimator = RandomForestClassifier(random_state=0)
x, y = make_classification(n_samples=1000, random_state=0)
sh = HalvingGridSearchCV(base_estimator, paramgrid, cv=6,
factor=2, resource='n_estimators',
max_resources=30).fit(x, y)
sh.best_estimator_
RandomForestClassifier(max_depth=5, n_estimators=24, random_state=0)
from sklearn.datasets import make_classification
from sklearn.svm import SVC
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV
import pandas as pds
paramgrid= {'kernel': ('linear', 'rbf'),
'C': [2, 10, 100]}
base_estimator = SVC(gamma='scale')
x, y = make_classification(n_samples=1000)
sh = HalvingGridSearchCV(base_estimator, paramgrid, cv=6,
factor=2, min_resources=20).fit(x, y)
sh.n_resources_
sh = HalvingGridSearchCV(base_estimator, paramgrid, cv=5,
factor=2, min_resources='exhaust').fit(x, y)
sh.n_resources_
from sklearn.datasets import make_classification
from sklearn.svm import SVC
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV
import pandas as pds
paramgrid = {'kernel': ('linear', 'rbf'),
'C': [2, 10, 100]}
base_estimator = SVC(gamma='scale')
x, y = make_classification(n_samples=1000)
sh = HalvingGridSearchCV(base_estimator, paramgrid, cv=6,
factor=2, max_resources=40,
aggressive_elimination=False).fit(x, y)
sh.n_resources_
sh = HalvingGridSearchCV(base_estimator, paramgrid, cv=5,
factor=2,
max_resources=40,
aggressive_elimination=True,
).fit(x, y)
sh.n_resources_
输出:
在下面的输出中，我们可以看到 Scikit 学习交叉验证超参数，它选择屏幕上显示的理想模型。
Scikit learn cross-validation hyperparameter
阅读: Scikit 学习超参数调整
Scikit 学习交叉验证洗牌
在本节中，我们将学习 python 中的 scikit learn 交叉验证 shuffle works 。
交叉验证混洗被定义为用户生成训练和测试分割首先数据样本被混洗，然后被分割成训练和测试集。
代码:
在下面的代码中，我们将学习导入一些库，我们可以从中混洗数据，然后将数据分成训练和测试。
- x = num.array([[1，2]，[3，4]，[1，2]，[3，4]]) 用于生成数组。
kf = KFold(n_splits=2)用于拆分数据。- print("TRAIN:"，train_index，" TEST:"，test_index) 用于打印训练和测试数据。
import numpy as num
from sklearn.model_selection import KFold
x = num.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = num.array([1, 2, 3, 4])
kf = KFold(n_splits=2)
kf.get_n_splits(x)
print(kf)
for train_index, test_index in kf.split(x):
print("TRAIN:", train_index, "TEST:", test_index)
x_train, x_test = x[train_index], x[test_index]
y_train, y_test = y[train_index], y[test_index]
输出:
运行上面的代码后，我们得到了下面的输出，我们可以看到，在此之后的数据洗牌将它分为训练和测试数据。
scikit learn cross-validation shuffle
阅读: Scikit 学习 hidden _ layer _ size
Scikit 学习交叉验证网格搜索
在本节中，我们将了解 Scikit 如何在 python 中学习交叉验证网格搜索工作。
交叉验证网格搜索被定义为为所有参数化网格模型选择最佳参数的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以从网格中选择最佳参数。
iris = datasets . load _ iris()用于加载 iris 数据集。- parameters = { ' kernel '😦' linear '，' rbf ')，' C':[1，12]} 用于定义参数。
- classifier.fit(iris.data，iris.target) 用于拟合模型。
- 已排序(classifier.cv_results_。()【keys】用于对分类器进行排序。
from sklearn import svm, datasets
from sklearn.model_selection import GridSearchCV
iris = datasets.load_iris()
parameters = {'kernel':('linear', 'rbf'), 'C':[1, 12]}
svc = svm.SVC()
classifier = GridSearchCV(svc, parameters)
classifier.fit(iris.data, iris.target)
sorted(classifier.cv_results_.keys())
输出:
在下面的输出中，我们可以看到屏幕上显示了从参数网格中搜索到的最佳参数。
scikit learn cross-validation grid search
另外，看看更多的 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit learn 交叉验证，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习交叉验证
- Scikit 学习交叉验证分数
- Scikit 学习交叉验证套索
- Scikit 学习交叉验证预测
- Scikit 学习交叉验证时间序列
- Scikit 学习交叉验证分离
- Scikit 学习交叉验证混淆矩阵
- Scikit 学习交叉验证超参数
- Scikit 学习交叉验证混洗
- Scikit 学习交叉验证网格搜索
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习决策树
在这个 Python 教程中，我们将学习如何用 Python 创建一个 scikit learn 决策树，我们还将涵盖与决策树相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习决策树
- Scikit 学习决策树分类器
- Scikit 学习决策树分类器示例
- Scikit 学习决策树回归器
- Scikit 学习决策树可视化
- Scikit 学习决策树修剪
- Scikit 学习决策树分类
- Scikit 学习决策树准确性
目录
- Scikit 学习决策树
- Scikit 学习决策树分类器
- Scikit 学习决策树分类器示例
- Scikit 学习决策树回归器
- Scikit 学习决策树可视化
- Scikit 学习决策树剪枝
- Scikit 学习决策树分类
- Scikit 学习决策树准确性
Scikit 学习决策树
在本节中，我们将学习如何在 python 中制作 scikit-learn 决策树。
- 决策树是一个类似流程图的树结构，它由分支组成，每个分支代表一个决策规则。树的分支被称为节点。
- 我们有一个分割过程，将节点分割成子节点。决策树的最顶层节点被称为根节点。
- 有些线将节点分成子节点，子节点甚至被分成偶数个子节点，然后初始子节点称为决策节点。
- 不再分裂的节点称为叶节点或终端节点。整个树的子部分被称为分支或子树。
- 我们也可以称该节点为父节点和子节点。被分成子节点的节点被称为父节点，子节点被称为父节点的子节点。
Scikit learn decision tree
正如我们在上面的图片中看到的，节点被分割成子节点。我们还可以在决策树中选择最佳分割点。
- 决策树分割所有可用变量上的节点。
- 选择产生最相似子节点的拆分。
- 决策树的时间复杂度是给定数据中记录数和属性数的方法。
- 决策树是一种不依赖于概率分布的非参数方法。
另外，检查: Scikit-learn 逻辑回归
Scikit 学习决策树分类器
在本节中，我们将学习如何用 python 创建 scikit learn 决策树分类器。
-
决策树用于预测值，并且是用于分类和回归的非参数监督学习方法。
-
决策树分类器是可用于对数据集执行多类分类的类。
-
决策树分类器接受两个数组的输入，如数组 X 和数组 Y。数组 X 保存训练样本，数组 Y 保存训练样本。
-
决策树分类器支持二元分类以及多类分类。
代码:
在下面的代码中，我们将从 sklearn 库加载虹膜数据，并从 sklearn 导入树。
load_iris()用于加载数据集。- X，Y = iris.data，iris.target 用于训练数据和测试数据。
- 树。决策树分类器()用于制作决策树分类器。
- 树。DecisionTreeClassifier() 用于将数据放入树中。
tree . plot _ tree(clasifier)用于在屏幕上绘制决策树。
from sklearn.datasets import load_iris
from sklearn import tree
iris = load_iris()
X, Y = iris.data, iris.target
clasifier = tree.DecisionTreeClassifier()
clasifier = clasifier.fit(X, Y)
tree.plot_tree(clasifier)
输出:
运行上面的代码后，我们得到下面的输出，可以看到屏幕上绘制了决策树。
scikit learn decision tree classifier
Read: Scikit-learn Vs Tensorflow
Scikit 学习决策树分类器示例
在本节中，我们将学习如何用 Python 制作一个 scikit learn 决策树示例。
- 我们知道决策树是用来预测价值的，它是非参数的监督学习。
- 决策树分类器接受两个数组的输入，如数组 X 和数组 Y。数组 X 保存训练样本，数组 Y 保存训练样本。
举例:
在下面的例子中，我们将导入 graphviz 库。Graphviz 被定义为用于创建图表的开源模块。
- tree.export_graphviz(clf，out_file=None) 用于在屏幕上创建树形图。
tree.export_graphviz()用于在树形图内部添加一些变量。- graphviz。source(dot data)用于从数据源获取数据。
import graphviz
dotdata = tree.export_graphviz(clf, out_file=None)
graphs = graphviz.Source(dotdata)
graphs.render("iris")
dotdata = tree.export_graphviz(clf, out_file=None,
feature_names=iris.feature_names,
class_names=iris.target_names,
filled=True, rounded=True,
special_characters=True)
graphs = graphviz.Source(dotdata)
graphs
输出:
运行上面的代码后，我们得到了下面的输出，从中我们可以看到在 Graphviz 的帮助下绘制了一个决策树图。
Scikit learn decision tree classifier example
Scikit 学习决策树回归器
在继续之前，我们应该了解一些关于回归变量的知识。
- 在 Regressor 中，我们只是预测值，或者我们可以说它是一种研究自变量和因变量之间关系的建模技术。
- 在回归分析中，我们有因变量和自变量。这里，因变量作为响应，自变量作为特征。
- 回归变量有助于我们理解因变量的值相对于自变量是如何变化的。
代码:
在下面的代码中，我们将导入一些库 import numy 作为 np ，从 sklearn.tree 中导入来自 import DecisionTreeRegressor ，从中导入 matplotlib.pyplot 作为 plot。
np.random.RandomState(1)用于创建随机数据集。- regression_1.fit(X，y) 用于填充回归模型。
regression _ 1 . predict(X _ test)用于预测数据。plot.figure()用于绘制图形。plot.xlabel("data")用于绘制图形上的 x 标签。plot.ylabel("target")用于在图形上绘制 y 标签。- plot.title("决策树回归")用来给图加标题。
import numpy as np
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plot
range = np.random.RandomState(1)
X = np.sort(5 * range.rand(80, 1), axis=0)
Y = np.sin(X).ravel()
Y[::5] += 3 * (0.5 - range.rand(16))
regression_1 = DecisionTreeRegressor(max_depth=2)
regression_2 = DecisionTreeRegressor(max_depth=5)
regression_1.fit(X, y)
regression_2.fit(X, y)
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
Y1 = regression_1.predict(X_test)
Y2 = regression_2.predict(X_test)
plot.figure()
plot.scatter(X, y, s=20, edgecolor="black", c="pink", label="data")
plot.plot(X_test, Y1, color="blue", label="max_depth=4", linewidth=2)
plot.plot(X_test, Y2, color="green", label="max_depth=7", linewidth=2)
plot.xlabel("data")
plot.ylabel("target")
plot.title("Decision Tree Regression")
plot.legend()
plot.show()
输出:
运行上面的代码后，我们得到了下面的输出，从中我们可以看到绘制了决策树回归器。绿色的线是实际数据，虚线是我们的预测数据。
scikit learn decision tree regressor
Scikit 学习决策树可视化
在本节中，我们将了解如何让 scikit 学习 python 中的决策树可视化。
在前进之前，我们应该有一些关于视觉化的知识。
- 可视化被定义为将大型数据集转换为图形、图表或树的形式的过程。
- 决策树可视化还将大量数据转换成用户可以更好地理解的树形格式。
- 决策树可视化使用 sklearn 树方法 Plot_tree.sklearn IRIS 数据集完成。
代码:
在下面的代码中，我们将导入一些库 import matplotlib.pyplot 作为 plot ，sklearn 导入数据集中的，sklearn.model_selection 导入 train_test_split ，sklearn.tree 导入决策树分类器中的。
iris = datasets . load _ iris()用于加载 iris 数据集。- X_train，X_test，Y_train，Y_test = train_test_split(X，Y，test_size=0.5，random_state=1，strategy = Y)用于创建训练或测试数据集。
- classifier _ tree = DecisionTreeClassifier(criteria = ' Gini '，max_depth=6，random_state=1) 用于使用 decision tree classifier 训练模型。
- tree . plot _ tree(classifier _ tree，fontsize=12) 用于绘制决策树。
import matplotlib.pyplot as plot
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
iris = datasets.load_iris()
X = iris.data[:, 2:]
Y = iris.target
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.5, random_state=1, stratify=Y)
classifier_tree = DecisionTreeClassifier(criterion='gini', max_depth=6, random_state=1)
classifier_tree.fit(X_train, Y_train)
figure, axis = plot.subplots(figsize=(12, 12))
tree.plot_tree(classifier_tree, fontsize=12)
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制了 scikit learn 决策树可视化。
Scikit learn decision tree visualization
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习决策树剪枝
在这一节中，我们将了解如何让 scikit 学习 python 中的决策树双关语。
剪枝被定义为一种数据压缩技术，其中数据正在收缩，并且决策树算法的大小通过仅移除树的一部分来减小。
代码:
在下面的代码中，我们导入一些库导入 matplotlib.pyplot 为 plt ，来自 sklearn.model _ selction 导入 train_test_split ，来自 sklearn.tree 导入 load_breast cancer。
load _ breast _ cancer(return _ X _ y = True)用于加载乳腺癌的数据。- X_train，X_test，y_train，y_test = train_test_split(X，y，random_state=0) 用于拆分训练和测试数据。
- 决策树分类器(random_state=0
)用于绘制决策树分类器的随机状态。 - axis . plot(CCP _ 阿尔法斯[:-1]，杂质[:-1]，marker="o "，drawstyle="steps-post") 用于绘制轴。
- axis.set_xlabel("有效 alpha") 用于给图加 x 标签。
- axis.set_ylabel(“叶子的总杂质”)用于为图表提供 y 标签。
- axis.set_title("总杂质 vs 训练集的有效α")用于给图加标题。
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
clasifier = DecisionTreeClassifier(random_state=0)
path = clasifier.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities
fig, axis = plt.subplots()
axis.plot(ccp_alphas[:-1], impurities[:-1], marker="o", drawstyle="steps-post")
axis.set_xlabel("Effective alpha")
axis.set_ylabel("Total impurity of leaves")
axis.set_title("Total Impurity vs effective alpha for training set")
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到叶子的总杂质。
scikit learn decision tree punning
另外，检查: Scikit 学习随机森林
Scikit 学习决策树分类
在这一节中，我们将了解如何让 scikit 学习 Python 中的决策树分类。
- 分类是与分类变量等价的数据类型。它需要固定数量的可能值。
- 分类变量可以将变量分成不同的类别，例如性别、类型、类别，
代码:
在下面的代码中，我们将从 matplotlib 导入 pyplot 作为 plt，从 sklearn 导入数据集导入一些 librarie s ，从 sklearn.tree 导入决策树分类器。****
- 我们可以从虹膜数据集中收集数据，并将数据分类。
- tree.plot_tree(clf，feature _ names = iris . feature _ names，class_names=iris.target_names，filled=True) 用于在屏幕上绘制数据。
from matplotlib import pyplot as plt
from sklearn import datasets
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
iris = datasets.load_iris()
X = iris.data
y = iris.target
fig = plt.figure(figsize=(25,20))
_ = tree.plot_tree(clf,
feature_names=iris.feature_names,
class_names=iris.target_names,
filled=True)
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到数据被分成了不同的类别。
scikit-learn decision tree categorical
阅读: Scikit 学习线性回归
Scikit 学习决策树准确性
在这一节中，我们将学习如何在 python 中使 scikit 决策树精确化。
- 精度用于测量模型在测量真阳性和真阴性之和时的性能。
- 准确度被定义为正确分类的案例数占被评估案例总数的比例。
代码:
在下面的代码中，我们将导入一些库来查找决策树的准确性。
data = PD . read _ CSV(" diabetes . CSV "，header=None，names=col_names) 用于从数据集读取数据。
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn import metrics
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
data = pd.read_csv("diabetes.csv", header=None, names=col_names)
从 data.head()函数中，我们得到了数据集的前五行。
data.head()
如图所示，我们从 data.head() 函数的数据集中获取前五行。
在下面的代码中，我们将数据和目标变量分开以获得准确性。
print("Accuracy:"，metrics.accuracy_score(y_train，y_pred)) 用于打印屏幕上数据的精度。
feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = data[feature_cols]
y = data.label
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)
clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)
y_pred = clf.predict(X_train)
print("Accuracy:",metrics.accuracy_score(y_train, y_pred))
运行上面的代码后，我们得到下面的输出，从中我们可以看到模型的准确性。
scikit learn decision tree accuracy
您可能还想阅读以下 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit learn 决策树，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习决策树
- Scikit 学习决策树分类器
- Scikit 学习决策树分类器示例
- Scikit 学习决策树回归器
- Scikit 学习决策树可视化
- Scikit 学习决策树修剪
- Scikit 学习决策树分类
- Scikit 学习决策树准确性
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习功能选择
在这个 Python 教程中，我们将学习 python 中的 Scikit learn 特性选择，我们还将涵盖与特性选择相关的不同示例。我们将讨论这些话题。
- Scikit 学习功能选择
- Scikit 学习功能选择管道
- Scikit 学习功能选择 chi2
- Scikit 学习功能选择 rfe
- Scikit 学习功能选择选择测试
- Scikit 学习基于特征选择树估计器
- Scikit 学习特征选择分类
- Scikit 学习特征选择交互信息
- Scikit 学习功能选择 PCA
目录
- Scikit 学习功能选择
- Scikit 学习功能选择管道
- Scikit 学习功能选择 chi2
- Scikit 学习特性选择 rfe
- Scikit 学习功能选择 selectkbest
- Scikit 学习基于特征选择树的估计器
- Scikit 学习特征选择分类
- Scikit 学习特征选择交互信息
- Scikit 学习特征选择 PCA
Scikit 学习功能选择
在本节中，我们将了解scikit 如何在 Python 中学习特性选择工作。
- 当我们开发预测模型时使用特征选择，它用于减少输入变量的数量。
- 它还参与评估每个输入变量和目标变量之间的关系。
代码:
在下面的代码中，我们将从 sklearn.feature_selection 导入 varianceThreshold ，我们可以从中选择特性。
此外，select = variance threshold(threshold =(. 8 *(1-. 8)))用于计算来自特征选择的方差阈值。
from sklearn.feature_selection import VarianceThreshold
X = [[0, 0, 1], [0, 1, 0], [1, 0, 0], [0, 1, 1], [0, 1, 0], [0, 1, 1]]
select = VarianceThreshold(threshold=(.8 * (1 - .8)))
select.fit_transform(X)
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到方差阈值删除了所有样本中具有相同值的所有零方差特征。
scikit learn feature selection
另外，请阅读: Scikit-learn Vs Tensorflow
Scikit 学习功能选择管道
在本节中，我们将了解 Python 中的 Scikit 学习特性选择管道工作。
流水线被线性地用于应用一系列语句。它用于删除训练集中一些不太重要的特征，还用于选择提高模型准确性的最佳特征。
代码:
在下面的代码中，我们将从 sklearn.pipeline 导入管道。流水线用于移除一些不太重要的特征，并且还选择提高准确度的最佳特征。
- pipeline.fit(x_train，y_train) 用于避免测试集泄露到训练集中。
- pipeline.score(x_test，y_test) 用于计算模型的得分。
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
x, y = make_classification(random_state=0)
x_train, x_test, y_train, y_test = train_test_split(x, y,random_state=0)
pipeline = Pipeline([('scaler', StandardScaler()), ('svc', SVC())])
pipeline.fit(x_train, y_train)
Pipeline(steps=[('scaler', StandardScaler()), ('svc', SVC())])
pipeline.score(x_test, y_test)
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到屏幕上显示了模型通过管道得到的改进的准确性分数。
scikit learn feature selection pipeline
Scikit 学习功能选择 chi2
在这一节中，我们将了解scikit 如何在 python 中学习特性选择 chi2 的工作方式。
Chi2 检验用于测量非线性变量之间的相关性。它只包含非负变量，如布尔或频率。
代码:
在下面的代码中，我们将从 sklearn.feature_selection 导入 chi2，它测量非线性变量之间的依赖关系。
- X，y = load _ iris(return _ X _ y = True)用于从 iris 加载数据。
X.shape用于管理数据的形状。
from sklearn.datasets import load_iris
from sklearn.feature_selection import chi2
X, y = load_iris(return_X_y=True)
X.shape
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到非线性变量被打印在屏幕上。
scikit learn feature selection chi2
阅读: Scikit 学习决策树
Scikit 学习特性选择 rfe
在这一节中，我们将了解scikit 如何在 python 中学习特征选择 RFE 工作。
RFE 意味着递归特征消除，即给一个特征分配权重。递归特征消除的目标是选择较小的特征集。
代码:
在下面的代码中，我们将从 sklearn.feature_selection 导入 RFE，通过它我们可以选择较小的功能集。
digits = load_digits()用于加载数字数据集。- recursivefeatureelimination = RFE(estimator = SVC，n_features_to_select=1，step=1) 用于创建 RFE 对象，并对每个像素进行排序。
- plot.title("用 RFE 排列像素")用来给窗口加标题。
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.feature_selection import RFE
import matplotlib.pyplot as plot
digits = load_digits()
X = digits.images.reshape((len(digits.images), -1))
y = digits.target
svc = SVC(kernel="linear", C=1)
recursivefeatureelimination = RFE(estimator=svc, n_features_to_select=1, step=1)
recursivefeatureelimination.fit(X, y)
ranking = recursivefeatureelimination.ranking_.reshape(digits.images[0].shape)
plot.matshow(ranking, cmap=plot.cm.Blues)
plot.colorbar()
plot.title("Ranking of pixels with RFE")
plot.show()
输出:
运行上面的代码后，我们得到了下面的输出，我们可以看到像素 RFE 的排名绘制在屏幕上。
scikit learn feature selection RFE
Scikit 学习功能选择 selectkbest
在接下来的章节中，我们将了解Scikit 如何学习特性选择 selectKbest 在 Python 中的工作。
- 在前进之前，我们应该有一个选择最佳的知识。
- 选择最佳是从给定数据集提取最佳特征的过程。它可以根据 K 个最高分来选择特征。
代码:
在下面的代码中，我们将从 sklearn.feature_selection 导入 SelectkBest，通过它我们可以提取数据集的最佳特征。
- 从 sklearn.datasets 导入 load_iris 用于加载 iris 数据集，我们可以从中收集数据。
- X_new = SelectKBest(chi2，k=2)。fit_transform(X，y) 用于提取数据集的最佳特征。
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
X_new = SelectKBest(chi2, k=2).fit_transform(X, y)
X_new.shape
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
X_new = SelectKBest(chi2, k=2).fit_transform(X, y)
X_new.shape
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 SelectkBest 进程开始工作，并用于提取数据集的最佳特征。
scikit learn feature selection SelectkBest
阅读: Scikit 学习层次聚类
Scikit 学习基于特征选择树的估计器
在本节中，我们将了解 Scikit 如何在 Python 中学习基于特征选择树的工作。
基于树的估计器用于确定基于杂质的特征重要性，这又可用于消除不重要的特征。
代码:
在下面的代码中，我们将从 sklearn.esemble 导入 ExtraTreesClassifier，通过它我们可以确定特征的杂质。
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectFromModel
X, y = load_iris(return_X_y=True)
X.shape
运行上面的代码后，我们得到下面的输出，我们可以看到树分类器的形状打印在屏幕上。
scikit learn feature selection tree-based
在这里，我们可以估计特征的重要性，即树的特征有多重要。
clf = ExtraTreesClassifier(n_estimators=50)
clf = clf.fit(X, y)
clf.feature_importances_
scikit learn feature selection tree-based estimator
在这里，我们可以看到额外的基于树的估计器取消了不重要的特征，并确定了基于杂质的特征。
model = SelectFromModel(clf, prefit=True)
X_new = model.transform(X)
X_new.shape
scikit learn feature selection tree-based
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习特征选择分类
在本节中，我们将学习 Python 中的 Scikit 学习特征选择分类。
分类是监督学习，用于将不同的事物分类。
代码:
在下面的代码中，我们将导入不同的库，从中我们可以选择不同分类器的特性。
- x，y = load _ iris(return _ X _ y = True)用于加载 iris 数据集。
- SequentialFeatureSelector = SequentialFeatureSelector(KNN，n_features_to_select=3) 用于选择分类器的特征。
from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
x, y = load_iris(return_X_y=True)
knn = KNeighborsClassifier(n_neighbors=3)
sequentialfeatureselector = SequentialFeatureSelector(knn, n_features_to_select=3)
sequentialfeatureselector.fit(x, y)
输出:
运行上面的程序后，我们得到下面的输出，从中我们可以看到屏幕上的特征选择分类已经完成。
scikit learn feature selection classification
阅读: Scikit 学习岭回归
Scikit 学习特征选择交互信息
在本节中，我们将了解 Scikit 如何在 python 中学习特征选择交互 信息。
互信息用于度量变量之间的相关性。如果两个随机变量是独立的，则互信息等于零。
代码:
在下面的代码中，我们将**从**sk learn . feature _ selection导入 f_regression，mutual_info_regression，通过它我们可以从交互信息中选择一个特征。
- mutual info = mutual _ info _ regression(x，y) 用于获取互信息。
- plot.figure(figsize=(15，5)) 用于在屏幕上绘制图形。
- plot.scatter(x[:，i]，y，edgecolor="black "，s=20) 用于绘制散点图。
- plot.title("F-test={:.2f}，MI={:.2f} "。format(f_test[i]，mutualinfo[i])，fontsize=16) 用于给图赋予标题。
import numpy as np
import matplotlib.pyplot as plot
from sklearn.feature_selection import f_regression, mutual_info_regression
np.random.seed(0)
x = np.random.rand(1000, 3)
y = x[:, 0] + np.sin(6 * np.pi * x[:, 1]) + 0.1 * np.random.randn(1000)
f_test, _ = f_regression(x, y)
f_test /= np.max(f_test)
mutualinfo = mutual_info_regression(x, y)
mutualinfo /= np.max(mutualinfo)
plot.figure(figsize=(15, 5))
for i in range(3):
plot.subplot(1, 3, i + 1)
plot.scatter(x[:, i], y, edgecolor="black", s=20)
plot.xlabel("$x_{}$".format(i + 1), fontsize=14)
if i == 0:
plot.ylabel("$y$", fontsize=14)
plot.title("F-test={:.2f}, MI={:.2f}".format(f_test[i], mutualinfo[i]), fontsize=16)
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到散点图绘制在屏幕上。
scikit learn feature selection mutual information
阅读: Scikit 学习随机森林
Scikit 学习特征选择 PCA
在本节中，我们将了解Scikit 如何在 Python 中学习特性选择。
- 在继续之前，我们应该了解一些关于 Scikit learn PCA 的知识。
- PCA 代表主成分分析，其被用作使用数据的奇异值分解的线性维度。
代码:
在下面的代码中，我们将从 sklearn.decomposition 导入 PCA，通过它我们可以选择特性。
- dataseturl = " https://raw . githubusercontent . com/jbrownlee/Datasets/master/pima-Indians-diabetes . CSV "用于加载数据集。
- datanames = ['preg '，' plas '，' pres '，' skin '，' test '，' mass '，' pedi '，' age '，' class'] 即从数据集中给出名称。
PCA(n_components=3)用于提取特征。- print("解释的差异:% s " % fit . Explained _ Variance _ ratio _)用于在屏幕上打印差异。
import numpy
from pandas import read_csv
from sklearn.decomposition import PCA
dataseturl = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv"
datanames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(dataseturl, names=datanames)
array = dataframe.values
x = array[:,0:7]
y = array[:,7]
pca = PCA(n_components=3)
fit = pca.fit(x)
print("Explained Variance: %s" % fit.explained_variance_ratio_)
print(fit.components_)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到差异被打印在屏幕上。
scikit learn feature selection PCA
另外，看看更多的 scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit 学习功能选择，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习功能选择
- Scikit 学习功能选择管道
- Scikit 学习功能选择 chi2
- Scikit 学习功能选择 rfe
- Scikit 学习功能选择选择测试
- Scikit 学习基于特征选择树估计器
- Scikit 学习特征选择分类
- Scikit 学习特征选择交互信息
- Scikit 学习功能选择 PCA
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 了解高斯–您需要知道的一切
在这个 Python 教程中，我们将学习 Scikit 学习高斯如何在 Python 中工作，我们还将涵盖与 Scikit 学习高斯相关的不同示例。我们将讨论这些话题。
- Scikit 学习高斯
- Scikit 学习高斯混合模型
- Scikit 学习高斯过程
- Scikit 学习高斯回归
- Scikit 学习高斯回归示例
- Scikit 学习高斯朴素贝叶斯
- Scikit 学习高斯内核
- Scikit 学习高斯分类器
- Scikit 学习高斯过程分类器
- Scikit 学习高斯过程 RBF 核
在继续本教程之前，我们建议您阅读一下什么是 Python 中的 Scikit Learn。
目录
- Scikit 学习高斯
- Scikit 学习高斯混合模型
- Scikit 学习高斯过程
- Scikit 学习高斯回归
- Scikit 学习高斯回归示例
- Scikit 学习高斯朴素贝叶斯
- Scikit 学习高斯内核
- Scikit 学习高斯分类器
- Scikit 学习高斯过程分类器
- Scikit 学习高斯过程 RBF 内核
Scikit 学习高斯
在这一节中，我们将了解Scikit 如何在 python 中学习高斯函数。
Scikit learn Gaussian是一个有监督的机器学习模型。它用于解决回归和分类问题。- 高斯过程也被定义为具有多元分布的随机变量的有限群。
代码:
在下面的代码中，我们将导入一些可以解决回归问题的库。
- X = num.linspace(start=0，stop=12，num=1_000)。整形(-1，1) 用于创建一个行空间。
- plot.plot(X，Y，label=r"\(f(x) = x \sin(x)\) "，linestyle="dotted") 用于在屏幕上绘制图形。
- plot.xlabel("\(x\)") 用于绘制 xlabel。
- plot.ylabel("\(f(x)\)") 用于绘制 y 标签。
- 高斯= plot.title("真生成过程")用于给图加标题。
import numpy as num
X = num.linspace(start=0, stop=12, num=1_000).reshape(-1, 1)
Y = num.squeeze(X * num.sin(X))
import matplotlib.pyplot as plot
plot.plot(X, Y, label=r"$f(x) = x \sin(x)$", linestyle="dotted")
plot.legend()
plot.xlabel("$x$")
plot.ylabel("$f(x)$")
Gaussian = plot.title("True Generative Process")
Scikit learn Gaussian true generative process
range = num . random . random state(1)用于生成随机数。- X_train，Y _ train = X[training _ indexes]，Y[training _ indexes]用于创建训练和测试数据。
- gaussianprocess.fit(X_train，Y_train) 用于拟合模型。
- plot.plot(X，Y，label=r"\(f(x) = x \sin(x)\) "，linestyle="dotted" )用于绘制图形。
- plot.scatter(X_train，Y_train，label="Observations") 用于绘制散点图。
- plot.xlabel("\(x\)") 用于绘制 x 标签。
- plot.ylabel("\(f(x)\)") 用于绘制 y 标签。
- plot.title("无噪声数据集上的高斯过程回归")用于给图加标题。
range = num.random.RandomState(1)
training_indices = range.choice(num.arange(Y.size), size=8, replace=False)
X_train, Y_train = X[training_indices], Y[training_indices]
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF
kernel = 1 * RBF(length_scale=1.0, length_scale_bounds=(1e-2, 1e2))
gaussianprocess = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=9)
gaussianprocess.fit(X_train, Y_train)
gaussianprocess.kernel_
mean_prediction, std_prediction = gaussian_process.predict(X, return_std=True)
plot.plot(X, Y, label=r"$f(x) = x \sin(x)$", linestyle="dotted")
plot.scatter(X_train, Y_train, label="Observations")
plot.plot(X, mean_prediction, label="Mean Prediction")
plot.fill_between(
X.ravel(),
mean_prediction - 1.98 * std_prediction,
mean_prediction + 1.98 * std_prediction,
alpha=0.7,
label=r"95% confidence interval",
)
plot.legend()
plot.xlabel("$x$")
plot.ylabel("$f(x)$")
Gaussian = plot.title("Gaussian Process Regression on noise-free dataset")
运行上述代码后，我们得到以下输出，其中我们可以看到无噪声数据集上的高斯过程回归。
Scikit learn Gaussian
另外，检查: Scikit-learn 逻辑回归
Scikit 学习高斯混合模型
在本节中，我们将了解Scikit 如何在 python 中学习高斯混合模型的工作方式。
- Scikit 学习高斯混合模型用于定义表示高斯模型概率分布的过程。
- 高斯混合也允许评估模型的参数。
代码:
在下面的代码中，我们将导入一些代表高斯模型概率分布的库。
num.random.seed(0)用于生成两个分量的随机样本。- shiftedgaussian = num . random . randn(n _ samples，2) + num.array([25，25]) 用于生成球面数据。
- stretchedgaussian = num . dot(num . random . randn(n _ samples，2)，c) 用于生成以零为中心的拉伸高斯数据。
- X _ train = num . v stack([shiftedgaussian，stretchedgaussian]) 用于将两个数据集集中到最终的训练集中。
- 分类器=混合物。GaussianMixture(n_components=2，协方差 _type="full") 用于拟合具有两个分量的高斯混合模型。
- cs=plot.contour(X，Y，Z，norm=LogNorm(vmin=2.0，vmax=1000.0)，levels=num.logspace(0，3，10) ) 用于预测分数作为反标绘。
- plot.scatter(X_train[:，0]，X_train[:，1]，0.10) 用于绘制散点图。
- plot.title("高斯混合法预测的负对数似然")用于在图上标出标题。
- plot.axis("紧")用于在图形上绘制轴。
import numpy as num
import matplotlib.pyplot as plot
from matplotlib.colors import LogNorm
from sklearn import mixture
n_samples = 350
num.random.seed(0)
shiftedgaussian = num.random.randn(n_samples, 2) + num.array([25, 25])
c = num.array([[0.0, -0.9], [3.5, 0.9]])
stretchedgaussian = num.dot(num.random.randn(n_samples, 2), c)
X_train = num.vstack([shiftedgaussian, stretchedgaussian])
classifier = mixture.GaussianMixture(n_components=2, covariance_type="full")
classifier.fit(X_train)
x = num.linspace(-25.0, 35.0)
y = num.linspace(-25.0, 45.0)
X, Y = num.meshgrid(x, y)
XX = num.array([X.ravel(), Y.ravel()]).T
Z = -classifier.score_samples(XX)
Z = Z.reshape(X.shape)
cs = plot.contour(
X, Y, Z, norm=LogNorm(vmin=2.0, vmax=1000.0), levels=num.logspace(0, 3, 10)
)
cb = plot.colorbar(cs, shrink=0.10, extend="both")
plot.scatter(X_train[:, 0], X_train[:, 1], 0.10)
plot.title("Negative log-likelihood predicted by a Gaussian Mixture Method")
plot.axis("tight")
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到高斯混合方法是基于屏幕的。
Scikit learn Gaussian mixture model
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习高斯过程
在本节中，我们将了解Scikit 如何在 python 中学习高斯过程的工作方式。
- Scikit learn Gaussian processes 可用于回归和分类，在此帮助下，我们可以创建离散数据结构。
- 离散数据结构被定义为离散形式的数据。
代码:
在下面的代码中，我们将导入一些库，在高斯过程的帮助下，我们可以从中创建一个离散的数据结构。
self . baseline _ similarity _ bounds = baseline _ similarity _ bounds用于创建基线边界。- return sum([1.0 if C1 = = C2 else self . baseline _ similarity for C1 in S1 for C2 in S2])用于返回一对序列之间的核值。
- plot.figure(figsize=(8，5)) 用于在屏幕上绘制图形。
- plot . X ticks(num . arange(len(X))，X) 用于在图形上绘制 X 刻度。
- plot . y ticks(num . arange(len(X))，X) 用于在图形上绘制 y 刻度。
- plot.title("核下序列相似度")用于给出屏幕上的标题。
Gaussian process = Gaussian process regressor(kernel = kernel)用于处理高斯回归量。- Gaussian process . fit(X[training _ idx]，Y[training_idx]) 用于拟合模型。
- plot.bar(num.arange(len(X))，gp.predict(X)，color="r "，label="prediction") 用于在屏幕上绘制条形。
- plot . X ticks(num . arange(len(X))，X) 用于绘制 X 刻度。
- plot.title("序列上的回归")用于给图形赋予标题。
Gaussian process = Gaussian process classifier(kernel)用于处理高斯分类器。- plot.figure(figsize=(8，5)) 用于在屏幕上绘制图形。
import numpy as num
import matplotlib.pyplot as plot
from sklearn.gaussian_process.kernels import Kernel, Hyperparameter
from sklearn.gaussian_process.kernels import GenericKernelMixin
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.base import clone
class SequenceKernel(GenericKernelMixin, Kernel):
def __init__(self, baseline_similarity=0.6, baseline_similarity_bounds=(1e-5, 1)):
self.baseline_similarity = baseline_similarity
self.baseline_similarity_bounds = baseline_similarity_bounds
def hyperparameter_baseline_similarity(self):
return Hyperparameter(
"baseline_similarity", "numeric", self.baseline_similarity_bounds
)
def _f(self, s1, s2):
return sum(
[1.0 if c1 == c2 else self.baseline_similarity for c1 in s1 for c2 in s2]
)
def _g(self, s1, s2)
return sum([0.0 if c1 == c2 else 1.0 for c1 in s1 for c2 in s2])
def __call__(self, X, Y=None, eval_gradient=False):
if Y is None:
Y = X
if eval_gradient:
return (
num.array([[self._f(x, y) for y in Y] for x in X]),
num.array([[[self._g(x, y)] for y in Y] for x in X]),
)
else:
return num.array([[self._f(x, y) for y in Y] for x in X])
def diag(self, X):
return num.array([self._f(x, x) for x in X])
def is_stationary(self):
return False
def clone_with_theta(self, theta):
cloned = clone(self)
cloned.theta = theta
return cloned
kernel = SequenceKernel()
X = num.array(["AGCT", "AGC", "AACT", "TAA", "AAA", "GAACA"])
K = kernel(X)
D = kernel.diag(X)
plot.figure(figsize=(8, 5))
plot.imshow(num.diag(D ` -0.5).dot(K).dot(num.diag(D ` -0.5)))
plot.xticks(num.arange(len(X)), X)
plot.yticks(num.arange(len(X)), X)
plot.title("Sequence similarity Under kernel")
"""
Regression
"""
X = num.array(["AGCT", "AGC", "AACT", "TAA", "AAA", "GAACA"])
Y = num.array([2.0, 2.0, 3.0, 3.0, 4.0, 4.0])
training_idx = [1, 2, 3, 4]
gaussianprocess = GaussianProcessRegressor(kernel=kernel)
gaussianprocess.fit(X[training_idx], Y[training_idx])
plot.figure(figsize=(8, 5))
plot.bar(num.arange(len(X)), gp.predict(X), color="r", label="prediction")
plot.bar(training_idx, Y[training_idx], width=0.2, color="y", alpha=1, label="training")
plot.xticks(num.arange(len(X)), X)
plot.title("Regression On Sequences")
plot.legend()
"""
Classification
"""
X_train = num.array(["AGCT", "CGA", "TAAC", "TCG", "CTTT", "TGCT"])
Y_train = num.array([True, True, True, False, False, False])
gaussianprocess = GaussianProcessClassifier(kernel)
gaussianprocess.fit(X_train, Y_train)
X_test = ["AAA", "ATAG", "CTC", "CT", "C"]
Y_test = [True, True, False, False, False]
plot.figure(figsize=(8, 5))
plot.scatter(
num.arange(len(X_train)),
[1.0 if c else -1.0 for c in Y_train],
s=100,
marker="o",
edgecolor="none",
facecolor=(1, 0.75, 0),
label="training",
)
plot.scatter(
len(X_train) + num.arange(len(X_test)),
[1.0 if c else -1.0 for c in Y_test],
s=100,
marker="o",
edgecolor="none",
facecolor="b",
label="truth",
)
plot.scatter(
len(X_train) + num.arange(len(X_test)),
[1.0 if c else -1.0 for c in gp.predict(X_test)],
s=100,
marker="x",
edgecolor=(0, 2.0, 0.4),
linewidth=2,
label="prediction",
)
plot.xticks(num.arange(len(X_train) + len(X_test)), num.concatenate((X_train, X_test)))
plot.yticks([-1, 1], [False, True])
plot.title("Classification On Sequences")
plot.legend()
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到在 scikit learn Gaussian 进程的帮助下，离散数据结构被绘制在屏幕上。
Scikit learn Gaussian Processes
阅读: Scikit 学习随机森林
Scikit 学习高斯回归
在本节中，我们将了解Scikit 如何在 python 中学习高斯回归的工作方式。
Scikit learn 高斯回归被定义为一种在机器学习领域产生波动的非参数方法。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建一个高斯回归器。
- x，y = make_friedman2(n_samples=550，noise=0，random_state=0) 用于制作 friedman。
- gaussianProcessregression = GaussianProcessRegressor(内核=内核，随机状态=0)。fit(x，y) 用于创建高斯回归方程并拟合模型。
- gaussianprocessregression . score(x，y) 用于统计分数。
from sklearn.datasets import make_friedman2
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import DotProduct, WhiteKernel
x, y = make_friedman2(n_samples=550, noise=0, random_state=0)
kernel = DotProduct() + WhiteKernel()
gaussianProcessregression = GaussianProcessRegressor(kernel=kernel,
random_state=0).fit(x, y)
gaussianProcessregression.score(x, y)
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到屏幕上打印出了高斯回归函数的分数。
Scikit learn Gaussian regressor
阅读: Scikit 学习功能选择
Scikit 学习高斯回归示例
在本节中，我们将了解 Scikit 学习 python 中高斯回归的例子。
- Scikit 将高斯学习为具有多元分布随机变量的有限组。
- Scikit learn 高斯回归被定义为在区域中产生波的贝叶斯方法。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建一个回归图。
- x = num.linspace(0，7，num=30)。shape(-1，1) 用于创建一个 linspace。
- y = target_generator(x，add_noise=False) 用于创建目标生成器。
Gaussian regression = plot . y label(" y ")用于绘制图表上的 y 标签。range = num . random . random state(0)用于生成随机数。- plot.plot(x，y，label= "预期信号")用于绘制预期信号。
plot.xlabel("x")用于绘制 x 标签。- Gaussian process regression = Gaussian process regressor(kernel = kernel，alpha=0.0) 用于创建高斯回归量。
- y_mean，y _ STD = gaussianprocessregression . predict(x，return_std=True) 用于预测模型。
import numpy as num
def target_generator(x, add_noise=False):
target = 0.7 + num.sin(5 * x)
if add_noise:
range = num.random.RandomState(1)
target += range.normal(0, 0.5, size=target.shape)
return target.squeeze()
x = num.linspace(0, 7, num=30).reshape(-1, 1)
y = target_generator(x, add_noise=False)
import matplotlib.pyplot as plot
Gaussianregression= plot.ylabel("y")
range = num.random.RandomState(0)
x_train = range.uniform(0, 5, size=20).reshape(-1, 1)
y_train = target_generator(x_train, add_noise=True)
plot.plot(x, y, label="Expected signal")
plot.scatter(
x=x_train[:, 0],
y=y_train,
color="red",
alpha=0.4,
label="Observations",
)
plot.legend()
plot.xlabel("x")
Gaussianregression = plot.ylabel("y")
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel
kernel = 1.0 * RBF(length_scale=1e1, length_scale_bounds=(1e-2, 1e3)) + WhiteKernel(
noise_level=1, noise_level_bounds=(1e-5, 1e1)
)
gaussianprocessregression = GaussianProcessRegressor(kernel=kernel, alpha=0.0)
gaussianprocessregression.fit(x_train, y_train)
y_mean, y_std = gaussianprocessregression.predict(x, return_std=True)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上绘制的高斯回归示例。
Scikit learn Gaussian regressor example
阅读: Scikit 学习 hidden _ layer _ size
Scikit 学习高斯朴素贝叶斯
在这一节中，我们将了解到scikit 如何学习高斯朴素贝叶斯在 python 中的工作方式。
- 高斯朴素贝叶斯被定义为支持连续值特征的过程。
- 它创建了一个简单的模型，并通过简单地找到点的平均值和标准偏差来拟合该模型。
代码:
在下面的代码中，我们将导入一些库，从中创建高斯朴素贝叶斯分类器。
n_samples = 50000用于创建 n 个样本。n _ bin = 5校准曲线使用 5 个 bin。- x，y = make _ blob(n _ samples = n _ samples，centers=centers，shuffle=False，random_state=42) 用于生成 5 个 blob，一半的 blob 为正，一半为负。
- sample _ weight = NP . random . randomstate(42)。rand(y.shape[0]) 用于生成随机样本。
- x_train，x_test，y_train，y_test，sw_train，sw_test = train_test_split(x，y，sample_weight，test_size=0.9，random_state=42 ) 用于将数据集拆分为训练数据和测试数据。
- classifier.fit(x_train，y_train) 定义高斯不支持样本权重。
- 分类器 _ 保序= CalibratedClassifierCV(分类器，cv=2，方法= "保序")用于定义保序校准的高斯朴素贝叶斯。
- classifier _ sigmoid = calibrated classifiercv(classifier，cv=2，method="sigmoid") 用于定义为 sigmoid 校准的高斯朴素贝叶斯。
plot.figure()用于在屏幕上绘制图形。plot.scatter()用于绘制散点图。plot.title("Data")用于给图形加标题。
import numpy as num
import matplotlib.pyplot as plot
from matplotlib import cm
from sklearn.datasets import make_blobs
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import brier_score_loss
from sklearn.calibration import CalibratedClassifierCV
from sklearn.model_selection import train_test_split
n_samples = 50000
n_bins = 5
centers = [(-7, -7), (0, 0), (7, 7)]
x, y = make_blobs(n_samples=n_samples, centers=centers, shuffle=False, random_state=42)
y[: n_samples // 2] = 0
y[n_samples // 2 :] = 1
sample_weight = np.random.RandomState(42).rand(y.shape[0])
x_train, x_test, y_train, y_test, sw_train, sw_test = train_test_split(
x, y, sample_weight, test_size=0.9, random_state=42
)
classifier = GaussianNB()
classifier.fit(x_train, y_train)
probability_pos_classifier = classifier.predict_proba(x_test)[:, 1]
classifier_isotonic = CalibratedClassifierCV(classifier, cv=2, method="isotonic")
classifier_isotonic.fit(x_train, y_train, sample_weight=sw_train)
probability_pos_isotonic = classifier_isotonic.predict_proba(X_test)[:, 1]
classifier_sigmoid = CalibratedClassifierCV(classifier, cv=2, method="sigmoid")
classifier_sigmoid.fit(x_train, y_train, sample_weight=sw_train)
probability_pos_sigmoid = classifier_sigmoid.predict_proba(x_test)[:, 1]
print("Brier Score Losses: (the smaller the better)")
classifier_score = brier_score_loss(y_test, probability_pos_classifier, sample_weight=sw_test)
print("No Calibration: %1.3f" % clf_score)
classifier_isotonic_score = brier_score_loss(y_test, probability_pos_isotonic, sample_weight=sw_test)
print("With Isotonic Calibration: %1.3f" % classifier_isotonic_score)
classifier_sigmoid_score = brier_score_loss(y_test, probability_pos_sigmoid, sample_weight=sw_test)
print("With Sigmoid Calibration: %1.3f" % classifier_sigmoid_score)
plot.figure()
y_unique = num.unique(y)
colors = cm.rainbow(num.linspace(0.0, 1.0, y_unique.size))
for this_y, color in zip(y_unique, colors):
this_x = x_train[y_train == this_y]
this_sw = sw_train[y_train == this_y]
plot.scatter(
this_x[:, 0],
this_x[:, 1],
s=this_sw * 50,
c=color[num.newaxis, :],
alpha=0.5,
edgecolor="y",
label="Class %s" % this_y,
)
plot.legend(loc="best")
plot.title("Data")
plot.figure()
order = num.lexsort((probability_pos_classifier,))
plot.plot(prob_pos_clf[order], "b", label="No Calibration (%1.3f)" % classifier_score)
plot.plot(
prob_pos_isotonic[order],
"g",
linewidth=3,
label="Isotonic Calibration (%1.3f)" % classifier_isotonic_score,
)
plot.plot(
probability_pos_sigmoid[order],
"y",
linewidth=3,
label="Sigmoid Calibration (%1.3f)" % classifier_sigmoid_score,
)
plot.plot(
num.linspace(0, y_test.size, 51)[1::2],
y_test[order].reshape(25, -1).mean(1),
"r",
linewidth=3,
label=r"Empirical",
)
plot.ylim([-0.05, 1.05])
plot.xlabel("Instances Sorted According to Predicted Probability (uncalibrated GNB)")
plot.ylabel("P(y=1)")
plot.legend(loc="upper left")
plot.title("Gaussian naive Bayes probabilities")
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到高斯朴素贝叶斯图绘制在屏幕上。
Scikit learn Gaussian naive Bayes
阅读:
Scikit 学习高斯内核
在本节中，我们将了解 Scikit 如何在 python 中学习高斯内核。
Scikit 学习高斯核定义为 sigma 确定核的宽度的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以通过高斯核计算得分。
- x，y = load _ iris(return _ X _ y = True)用于加载数据。
- 内核= 1.0 * RBF(1.0) 用于计算内核。
- GaussianProcessClassifier = GaussianProcessClassifier(kernel = kernel，random_state=0)。fit(x，y)用于拟合模型。
- gaussianprocessclassifier . score(x，y) 用于计算得分。
from sklearn.datasets import load_iris
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
x, y = load_iris(return_X_y=True)
kernel = 1.0 * RBF(1.0)
gaussianprocessclassifier = GaussianProcessClassifier(kernel=kernel,
random_state=0).fit(x, y)
gaussianprocessclassifier.score(x, y)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到高斯核分数被打印在屏幕上。
scikit learn Gaussian kernel
阅读: Scikit 学习分类教程
Scikit 学习高斯分类器
在本节中，我们将了解Scikit 如何学习 python 中的高斯分类器。
Scikit learn Gaussian 分类器被定义为一种高效的方法，致力于将输入类条件分布建模。
代码:
在下面的代码中，我们将导入一些库，从中我们可以预测高斯分类器的概率。
- x，y = load _ iris(return _ X _ y = True)用于加载数据。
- GaussianProcessClassifier = GaussianProcessClassifier(kernel = kernel，random_state=0)。fit(x，y)用于拟合分类器模型。
- Gaussian classifier . predict _ proba(x[:2，]) 用于预测分类器的概率。
from sklearn.datasets import load_iris
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
x, y = load_iris(return_X_y=True)
kernel = 1.0 * RBF(1.0)
gaussianclassifier = GaussianProcessClassifier(kernel=kernel,
random_state=0).fit(x, y)
gaussianclassifier.score(x, y)
gaussianclassifier.predict_proba(x[:2,:])
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上预测了高斯分类器的概率。
Scikit learn Gaussian classifier
阅读: Scikit 学习超参数调整
Scikit 学习高斯过程分类器
在本节中，我们将了解Scikit 如何在 python 中学习高斯过程分类器的工作方式。
Scikit learn 高斯过程分类器被定义为拉普拉斯近似和支持多类分类的有效方法。
代码:
在下面的代码中，我们将导入一些库，在高斯过程分类器的帮助下，我们可以从中制作图形。
iris = datasets . load _ iris()用于加载一些虹膜数据。- X = iris.data[:，:2] 用于取前两个特征。
- Gaussian process classifier _ RBF _ isotropic = Gaussian process classifier(kernel = kernel)。fit(X，y)用于拟合模型。
- titles = ["各向同性 RBF "，"各向异性 RBF"] 用来给图加标题。
- Z = classifier . predict _ proba(num . c _[xx . ravel()，yy.ravel()]) 用于预测概率
- plot.imshow(Z，extent=(x_min，x_max，y_min，y_max)，origin="lower") 用于绘制图形。
- plot.scatter(X[:，0]，X[:，1]，c=num.array(["y "，" c "，" g"])[y]，edgecolors=(0，0，0)) 用于绘制散点图。
- plot.xlabel("萼片长度")用于绘制 x 标签。
- plot.title("%s，LML:%.3f(titles[i]，分类器. log_marginal_likelihood(分类器.内核 _)。)【θ】)
)用于在图上绘制标题。
import numpy as num
import matplotlib.pyplot as plot
from sklearn import datasets
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
iris = datasets.load_iris()
X = iris.data[:, :2]
y = num.array(iris.target, dtype=int)
h = 0.04
kernel = 1.0 * RBF([1.0])
gaussianprocessclassifier_rbf_isotropic = GaussianProcessClassifier(kernel=kernel).fit(X, y)
kernel = 1.0 * RBF([1.0, 1.0])
gaussianprocessclassifier_rbf_anisotropic = GaussianProcessClassifier(kernel=kernel).fit(X, y)
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = num.meshgrid(num.arange(x_min, x_max, h), num.arange(y_min, y_max, h))
titles = ["Isotropic RBF", "Anisotropic RBF"]
plot.figure(figsize=(12, 7))
for i, classifier in enumerate((gaussianprocessclassifier_rbf_isotropic, gaussianprocessclassifier_rbf_anisotropic)):
plot.subplot(1, 2, i + 1)
Z = classifier.predict_proba(num.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape((xx.shape[0], xx.shape[1], 3))
plot.imshow(Z, extent=(x_min, x_max, y_min, y_max), origin="lower")
plot.scatter(X[:, 0], X[:, 1], c=num.array(["y", "c", "g"])[y], edgecolors=(0, 0, 0))
plot.xlabel("Sepal length")
plot.ylabel("Sepal width")
plot.xlim(xx.min(), xx.max())
plot.ylim(yy.min(), yy.max())
plot.xticks(())
plot.yticks(())
plot.title(
"%s, LML: %.3f" % (titles[i], classifier.log_marginal_likelihood(classifier.kernel_.theta))
)
plot.tight_layout()
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制了高斯过程分类器图。
scikit learn Gaussian process classifier
阅读: Scikit 学习梯度下降
Scikit 学习高斯过程 RBF 内核
在本节中，我们将了解Scikit 如何学习高斯过程 RBF 内核在 python 中的工作方式。
Scikit 学习高斯过程 RBF 核定义为作为定标器或具有相同维数的核。
代码:
在下面的代码中，我们将导入一些库，在 RBF 内核的帮助下，我们可以从中制作一个图形。
- x = num.linspace(0，5，100) 用于创建一个 linspace。
- y _ samples = GPR _ model . sample _ y(X，n_samples) 用于创建样本模型。
axis.plot()用于绘制模型。- axis.plot(x，y_mean，color="blue "，label="Mean") 用于绘制轴。
- X_train = range.uniform(0，5，10)。整形(-1，1) 用于创建均匀范围。
- plot _ GPR _ samples(gaussianprocessregressor，n_samples=n_samples，axis=axs[0]) 用于绘制样本。
- axs[0]。set_title("来自先前分布的样本")用于给图形加标题。
- axs[1]。散点图(X_train[:，0]，y_train，color="red "，zorder=10，label="Observations") 用于绘制散点图。
import matplotlib.pyplot as plot
import numpy as num
def plot_gpr_samples(gpr_model, n_samples, axis):
x = num.linspace(0, 5, 100)
X = x.reshape(-1, 1)
y_mean, y_std = gpr_model.predict(X, return_std=True)
y_samples = gpr_model.sample_y(X, n_samples)
for idx, single_prior in enumerate(y_samples.T):
axis.plot(
x,
single_prior,
linestyle="--",
alpha=0.7,
label=f"Sampled function #{idx + 1}",
)
axis.plot(x, y_mean, color="blue", label="Mean")
axis.fill_between(
x,
y_mean - y_std,
y_mean + y_std,
alpha=0.1,
color="blue",
label=r"$\pm$ 1 std. dev.",
)
axis.set_xlabel("x")
axis.set_ylabel("y")
axis.set_ylim([-3, 3])
range = num.random.RandomState(4)
X_train = range.uniform(0, 5, 10).reshape(-1, 1)
y_train = num.sin((X_train[:, 0] - 2.5) ** 2)
n_samples = 5
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF
kernel = 1.0 * RBF(length_scale=1.0, length_scale_bounds=(1e-1, 10.0))
gaussianprocessregressor = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plot.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
plot_gpr_samples(gaussianprocessregressor, n_samples=n_samples, axis=axs[0])
axs[0].set_title("Samples from prior distribution")
gpr.fit(X_train, y_train)
plot_gpr_samples(gaussianprocessregressor, n_samples=n_samples, axis=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Samples from posterior distribution")
fig.suptitle("Radial Basis Function kernel", fontsize=18)
plot.tight_layout()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制了 scikit learn Gaussian process RBF 内核图。
scikit learn Gaussian process RBF kernel
另外，看看更多的 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit learn Gaussian ，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习高斯
- Scikit 学习高斯混合模型
- Scikit 学习高斯过程
- Scikit 学习高斯回归
- Scikit 学习高斯回归示例
- Scikit 学习高斯朴素贝叶斯
- Scikit 学习高斯内核
- Scikit 学习高斯分类器
- Scikit 学习高斯过程分类器
- Scikit 学习高斯过程 RBF 核
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习遗传算法
在本 Python 教程中，我们将学习sci kit learn 遗传算法如何工作，我们还将涵盖与遗传算法相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习遗传算法
- Scikit 学习遗传选项
- Scikit 学习遗传算法特征选择
- Scikit 学习遗传选择 cv
- Scikit 学习遗传算法的优缺点
目录
Scikit 学习遗传算法
在这一节，我们将学习如何 scikit 学习遗传算法如何在 python 中工作。
- 在前进之前，我们应该有一些关于遗传学的知识。基因被定义为生物进化或与基因有关的品种。
- 遗传算法完全专注于自然选择，轻松解决有约束和无约束升级或者我们可以说优化问题。
代码:
在下面的代码中，我们将导入 GeneticSelectionCv ，从中我们可以从数据集中选择特性。
from _ _ future _ _ import print _ function用于将打印功能从 python 3 引入 python 2.6。- x = num.hstack((iris.data，e)) 用于逐列堆叠输入数组的序列。
- 选择器= selectors.fit(x，Y) 用于将数据拟合到模型中。
print(selectors . support _)用于打印选中的数据。
from __future__ import print_function
import numpy as num
from sklearn import datasets, linear_model
from genetic_selection import GeneticSelectionCV
def main():
iris = datasets.load_iris()
**# Some noisy data not correlated**
e = num.random.uniform(0, 0.2, size=(len(iris.data), 30))
x = num.hstack((iris.data, e))
Y = iris.target
estimators = linear_model.LogisticRegression(solver="liblinear", multi_class="ovr")
selectors = GeneticSelectionCV(estimators,
cv=6,
verbose=2,
scoring="accuracy",
max_features=6,
n_population=60,
crossover_proba=0.6,
mutation_proba=0.2,
n_generations=50,
crossover_independent_proba=0.6,
mutation_independent_proba=0.06,
tournament_size=4,
n_gen_no_change=20,
caching=True,
n_jobs=-2)
selectors = selectors.fit(x, Y)
print(selectors.support_)
if __name__ == "__main__":
main()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到所选的特性被打印在屏幕上。
scikit learn genetic algorithm
另外，请查看: Scikit-learn 与 tensor flow–详细对比
Scikit 学习基因选项
在这一节中，我们将学习 python 中的基因选择是如何工作的。
- Scikit learn genetic opt 定义为观察到的优化交叉验证指标的一组参数。
- 它使用进化算法来选择特征并设计不同的分类或回归模型。
代码:
在下面的代码中，我们将导入不同的库，从这些库中我们可以借助 genetic opt 找到分类问题。
GASearchCV用于使用进化算法运行拟合过程。data = load_digits()用于加载数据。- x = data . images . shape((n sample，-1)) 用于对数据图像进行整形。
- cv = StratifiedKFold(n _ splits = 3，shuffle=True) 用作交叉验证策略 is 可能只是 int。
- evolved _ estimator . fit(x _ train，y_train) 用于训练和优化估计器。
import matplotlib.pyplot as plot
from sklearn_genetic import GASearchCV
from sklearn_genetic.space import Categorical, Integer, Continuous
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_digits
from sklearn.metrics import accuracy_score
data = load_digits()
nsample = len(data.images)
x = data.images.reshape((nsample, -1))
y = data['target']
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.33, random_state=42)
_, axes = plot.subplots(nrows=1, ncols=4, figsize=(10, 3))
for axis, image, label in zip(axes, data.images, data.target):
axis.set_axis_off()
axis.imshow(image, cmap=plot.cm.gray_r, interpolation='nearest')
axis.set_title('Training: %i' % label)
param_grid = {'min_weight_fraction_leaf': Continuous(0.01, 0.5, distribution='log-uniform'),
'bootstrap': Categorical([True, False]),
'max_depth': Integer(2, 30),
'max_leaf_nodes': Integer(2, 35),
'n_estimators': Integer(100, 300)}
classifier = RandomForestClassifier()
cv = StratifiedKFold(n_splits=3, shuffle=True)
**# The main class from sklearn-genetic-opt**
evolved_estimator = GASearchCV(estimator=classifier,
cv=cv,
scoring='accuracy',
param_grid=param_grid,
n_jobs=-1,
verbose=True)
evolved_estimator.fit(x_train, y_train)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到数据在 GASearchCV 的帮助下被拟合并打印在屏幕上。
scikit learn genetic opt
Scikit 学习遗传算法特征选择
在本节中，我们将学习 scikit 如何在 python 中学习遗传算法特征选择。
- 特征选择被定义为当预测模型由开发者开发时减少输入变量数量的过程。
- 遗传算法是对问题的最优值进行自然选择的过程。
代码:
在下面的代码中，我们将导入一些库，通过这些库，我们可以在遗传选择函数的帮助下选择特性。
data = load _ breast _ cancer()用于加载乳腺癌数据集。- dataframe = pds。DataFrame(data.data，columns=data.feature_names) 用于导入数据集。
- models = models.fit(x，y) 用于将数据拟合到模型中。
- print('Feature Selection:'，x.columns[models.support_]) 用于在屏幕上打印所选特征。
from sklearn.datasets import load_breast_cancer
from genetic_selection import GeneticSelectionCV
from sklearn.tree import DecisionTreeClassifier
import pandas as pds
import numpy as num
data = load_breast_cancer()
dataframe = pds.DataFrame(data.data, columns=data.feature_names)
dataframe['target'] = data.target
x = dataframe.drop(['target'], axis=1)
y = dataframe['target'].astype(float)
estimators = DecisionTreeClassifier()
models = GeneticSelectionCV(
estimators, cv=5, verbose=0,
scoring="accuracy", max_features=5,
n_population=100, crossover_proba=0.5,
mutation_proba=0.2, n_generations=50,
crossover_independent_proba=0.5,
mutation_independent_proba=0.04,
tournament_size=3, n_gen_no_change=10,
caching=True, n_jobs=-1)
models = models.fit(x, y)
print('Feature Selection:', x.columns[models.support_])
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到特性选择被打印在屏幕上。
scikit learn genetic algorithm feature selection
阅读: Scikit 学习决策树
Scikit 学习基因选择 cv
在本节中，我们将了解scikit 如何在 python 中学习遗传选择 cv 的工作方式。
scikit learn 遗传选择被定义为探索函数的最佳值的自然选择过程
代码:
在下面的代码中，我们将从 genetic_selection 导入 GeneticSelectionCV，选择器通过它选择最佳特性。
from _ _ future _ _ import print _ function用于将打印功能从 python 3 引入 python 2.6。- e = np.random.uniform(0，0.1，size=(len(iris.data)，20)) 用于均匀生成随机数。
- x = np.hstack((iris.data，e)) 用于按列堆叠输入数组的序列。
GeneticSelectionCV()用于从样本空间中随机生成特征集。- selectors = selectors.fit(x，y) 用于拟合模型。
print(selectors . support _)用于打印选中的数据。
from __future__ import print_function
import numpy as num
from sklearn import datasets, linear_model
from genetic_selection import GeneticSelectionCV
def main():
iris = datasets.load_iris()
e = np.random.uniform(0, 0.1, size=(len(iris.data), 20))
x = np.hstack((iris.data, e))
y = iris.target
estimators = linear_model.LogisticRegression(solver="liblinear", multi_class="ovr")
selectors = GeneticSelectionCV(estimators,
cv=10,
verbose=4,
scoring="accuracy",
max_features=8,
n_population=70,
crossover_proba=0.7,
mutation_proba=0.4,
n_generations=80,
crossover_independent_proba=0.7,
mutation_independent_proba=0.07,
tournament_size=5,
n_gen_no_change=20,
caching=True,
n_jobs=-4)
selectors = selectors.fit(x, y)
print(selectors.support_)
if __name__ == "__main__":
main()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到所选的数据被打印在屏幕上。
scikit learn genetic selection cv
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习遗传算法的优缺点
在本节中，我们将学习关于 scikit 学习遗传算法的优点和缺点在 python 中。
优点:
- 遗传算法是很容易理解的人可以很容易地理解这个算法中发生的事情。
- 遗传算法对于噪声环境非常好。
- 遗传算法从染色体组或点群中搜索，而不是从单个点中搜索。
- 遗传算法使用概率转移规则，而不使用确定性规则。
- 遗传算法很容易并行化。
- 遗传算法可以很容易或很好地处理连续或离散问题。
- 遗传算法支持多目标优化。
- 遗传算法是概率性的、时间相关的、非线性的、非平稳的。
- 遗传算法需要的信息更少。
- 使用染色体的遗传算法。
劣势:
- 遗传算法要求或需要一个特殊的定义。
- 遗传算法需要较少的关于问题的信息，但是操作符编写和表示很困难。
- 遗传算法具有计算复杂性。
- 遗传算法非常耗时。
您可能还想阅读 Scikit learn 上的以下教程。
因此，在本教程中，我们讨论了****sci kit 学习遗传算法，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
*** Scikit 学习遗传算法
- Scikit 学习遗传选项
- Scikit 学习遗传算法特征选择
- Scikit 学习遗传选择 cv
- Scikit 学习遗传算法的优缺点
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习梯度下降
在本 Python 教程中，我们将学习Scikit learn Gradient descent 如何在python 中工作，我们还将涵盖与渐变 descent 相关的不同例子。此外，我们将涵盖这些主题。
- Scikit 学习梯度下降
- Scikit 学习梯度下降回归
- Scikit 学习随机梯度下降分类器
- Scikit 学习批次梯度下降
- Scikit 学习迷你批次梯度下降
- Scikit 学习随机梯度下降回归
- Scikit 学习逻辑回归梯度下降
- Scikit 学习梯度下降线性回归
目录
- Scikit 学习梯度下降
- Scikit 学习梯度下降回归
- Scikit 学习随机梯度下降分类器
- Scikit 学习随机梯度下降回归
- Scikit 学习批次梯度下降
- Scikit 学习迷你批次梯度下降
- Scikit 学习逻辑回归梯度下降
- Scikit 学习梯度下降线性回归
Scikit 学习梯度下降
在本节中，我们将了解Scikit 如何在python 中学习渐变下降。
- 梯度下降是机器学习的主干，在训练模型时使用。它还结合了每一个算法，很容易理解。
- Scikit learn 梯度下降是回归器和分类器的一种非常简单有效的方法。
- 它还适用于大规模和机器学习问题，并且在文本分类、自然语言处理方面也有经验。
- 在 scikit 学习梯度下降中，损失梯度一次猜测每个样本，然后更新我们的模型。
代码:
在下面的代码中，我们导入一些函数来计算损失、假设以及梯度。
- 假设= num.dot(X，theta) 用于计算假设。
- 损失=假设–Y用于计算损失。
CST = num . sum(loss * * 2)/(2 * a)用于计算成本。- theta = theta–alpha * gradient用于更新 theta 参数。
- Y[I]=(I+bias)+rand . uniform(0，2) *方差作为目标变量。
- X，Y = genData(90，20，9) 用于生成 90 个点，以 20 和 10 方差为基础，作为一点噪声。
- 打印(θ)用于打印θ的值。
import numpy as num
import random as rand
def gradientDescent(X, Y, theta, alpha, a, numIterations):
Xtrans = X.transpose()
for i in range(0, numIterations):
hypothesis = num.dot(X, theta)
loss = hypothesis - Y
cst = num.sum(loss ** 2) / (2 * a)
print("Iteration %d | Cost: %f" % (i, cst))
gradient = num.dot(Xtrans, loss) / a
theta = theta - alpha * gradient
return theta
def genData(numPoints, bias, variance):
X = num.zeros(shape=(numPoints, 3))
Y = num.zeros(shape=numPoints)
**# basically a straight line**
for i in range(0, numPoints):
X[i][0] = 2
X[i][1] = i
Y[i] = (i + bias) + rand.uniform(0, 2) * variance
return X, Y
X,Y = genData(90, 20, 9)
a, b = num.shape(X)
numIterations= 10000
alpha = 0.0004
theta = num.ones(b)
theta = gradientDescent(X,Y, theta, alpha,a, numIterations)
print(theta)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到点数已经生成，theta 的值打印在屏幕上。
Scikit learn gradient descent
Scikit 学习梯度下降回归
在本节中，我们将了解Scikit 如何学习梯度下降回归在 python 中工作。
- sci kit learn gradient descent regressor 被定义为计算成本函数并支持不同损失函数以拟合回归模型的过程。
- 梯度下降回归模型便于处理大量的训练数据。
代码:
在下面的代码中，我们将导入一些库，从中预测最佳回归线。
- 自我。X = X 用于定义一个类的方法。
y_pred = self.predict()函数用于预测模型。- self . a[0]= self . a[0]–(learning rate (1/b) NP . sum(y _ pred–y)))用于更新模型的系数。
- J =(1/2 * b)(NP . sum(y _ pred–self . y) * 2)用于计算模型的成本。
f = plt.figure(fig)用于在图形上绘制图形。- regr.plot_best_fit(y_pred，'初始最佳拟合线')用于绘制最佳拟合线。
- plot.plot(range(iterations)，costs，color='r') 用于验证成本函数的减少。
- regr . predict([I for I in range(10)])用于使用回归器进行预测。
import numpy as num
import matplotlib.pyplot as plot
class Linear_Regression:
def __init__(self, X, y):
self.X = X
self.y = y
self.a = [0, 0]
def update_coeffs(self, learningrate):
y_pred = self.predict()
y = self.y
b = len(y)
self.a[0] = self.a[0] - (learningrate * ((1/b) *
np.sum(y_pred - y)))
self.a[1] = self.a[1] - (learningrate * ((1/b) *
np.sum((y_pred - y) * self.X)))
def predict(self, X=[]):
y_pred = np.array([])
if not X: X = self.X
a = self.a
for x in X:
y_pred = np.append(y_pred, a[0] + (a[1] * x))
return y_pred
def get_current_accuracy(self, y_pred):
t, e = y_pred, self.y
s = len(y_pred)
return 1-sum(
[
abs(t[i]-e[i])/e[i]
for i in range(s)
if e[i] != 0]
)/s
def compute_cost(self, y_pred):
b = len(self.y)
J = (1 / 2*b) * (np.sum(y_pred - self.y)**2)
return J
def plot_best_fit(self, y_pred, fig):
f = plt.figure(fig)
plot.scatter(self.X, self.y, color='r')
plot.plot(self.X, y_pred, color='y')
f.show()
def main():
X = np.array([i for i in range(11)])
y = np.array([2*i for i in range(11)])
regr = Linear_Regression(X, y)
iterations = 0
steps = 90
learningrate = 0.01
costs = []
y_pred = regr.predict()
regr.plot_best_fit(y_pred, 'Initial best fit line')
while 1:
y_pred = regr.predict()
cst = regr.compute_cost(y_pred)
costs.append(cst)
regr.update_coeffs(learningrate)
iterations += 1
if iterations % steps == 0:
print(iterations, "epochs elapsed")
print("current accuracy is :",
regr.get_current_accuracy(y_pred))
break
**#final best-fit line**
regr.plot_best_fit(y_pred, 'Final Best Fit Line')
h = plot.figure('Verification')
plot.plot(range(iterations), costs, color='r')
h.show()
regr.predict([i for i in range(10)])
if __name__ == '__main__':
main()
输出:
运行上面的代码后，我们得到下面的代码输出，其中我们可以看到当前的精度和回归最佳拟合线绘制在屏幕上。
Scikit learn gradient descent regression
阅读: Scikit 学习决策树
Scikit 学习随机梯度下降分类器
在本节中，我们将了解sci kit 如何学习 python 中的随机梯度下降分类器。
Scikit learn 随机梯度下降分类器是一个寻找能够降低代价函数的系数的值的过程。
代码:
在下面的代码中，我们将从 sklearn.linear_model 中导入 SDGClassifier，通过它我们可以很容易的理解每一个算法。
- x = [[1。, 1.], [2., 2.]] 用于保存训练样本。
- y = [1，2] 用于保存目标样本。
- classifier.fit(x，y) 用于拟合分类器。
- 分类器预测。, 3.]]) 用于预测分类器。
classifier.coef_用于获取保存模型参数的分类器的系数。
from sklearn.linear_model import SGDClassifier
x = [[1., 1.], [2., 2.]]
y = [1, 2]
classifier = SGDClassifier(loss="hinge", penalty="l2", max_iter=7)
classifier.fit(x, y)
classifier.predict([[3., 3.]])
classifier.coef_
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到分类器的系数被打印在屏幕上。
scikit learn stochastic gradient descent classifier
阅读: Scikit 学习层次聚类
Scikit 学习随机梯度下降回归
在本节中，我们将在 python 中了解sci kit 随机梯度下降回归如何工作。
Scikit 学习随机梯度下降回归计算代价函数，支持损失函数。
代码:
在下面的代码中，我们将从 sklearn.linear_model 中导入 SGCRegressor，通过它我们可以计算函数的开销，并且还支持不同的对数函数。
range = num . random . random state(0)用于创建随机函数。y = range.randn(nsamples)用于保存目标样本。- x = range.randn(nsamples，nfeatures) 用于保存训练样本。
- regressor = make _ pipeline(standard scaler()、SGDRegressor(max_iter=100，tol=1e-3)) pipeline 用作带有拟合和预测功能的设置。
- regressor.fit(x，y) 用于拟合模型。
import numpy as num
from sklearn.linear_model import SGDRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
nsamples, nfeatures = 12,7
range = num.random.RandomState(0)
y = range.randn(nsamples)
x = range.randn(nsamples, nfeatures)
#Always scale the input.The most convenient way to use a pipeline.
regressor = make_pipeline(StandardScaler(),
SGDRegressor(max_iter=100, tol=1e-3))
regressor.fit(x, y)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上显示了回归函数。
Scikit learn stochastic gradient descent regressor
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习批次梯度下降
在本节中，我们将了解Scikit 如何在 python 中学习批量渐变下降的工作方式。
- 梯度下降是一个观察使函数代价最小的函数参数值的过程。
- 在批量梯度下降中，计算梯度时在每个步骤中使用整个数据集。它还在模型内部构建了简单的更新。
代码:
在下面的代码中，我们将从 sklearn.datasets 导入 make_regression，批处理梯度下降就是通过它来工作的。
- s = X.shape[0] 作为样本数。
- l oss =假设–Y用于计算损失。
J = num.sum(loss ** 2) / (2 * s)用于计算成本。- theta = theta–alpha *梯度用于更新 he 模型。
- X = num.c_[ num.ones(s)，X] 用于插入列中的值。
- Y _ predict = theta[0]+theta[1] X*用于预测值。
- pylab.plot(X[:，1]，Y，' r') 用于绘制图形。
import numpy as num
import random as rand
from sklearn.datasets import make_regression
import pylab
from scipy import stats
def gradient_descent_2(alpha, X, Y, numIterations):
s = X.shape[0]
theta = num.ones(2)
X_transpose = X.transpose()
for iter in range(0, numIterations):
hypothesis = num.dot(X, theta)
loss = hypothesis - Y
J = num.sum(loss ** 2) / (2 * s)
print ("iter %s | J: %.3f" % (iter, J))
gradient = np.dot(X_transpose, loss) / s
theta = theta - alpha * gradient
return theta
if __name__ == '__main__':
X, Y = make_regression(n_samples=100, n_features=1, n_informative=1,
random_state=0, noise=35)
s, q = num.shape(X)
X = num.c_[ num.ones(s), X] # insert column
alpha = 0.01 # learning rate
theta = gradient_descent_2(alpha, X, Y, 1000)
for i in range(X.shape[1]):
Y_predict = theta[0] + theta[1]*X
pylab.plot(X[:,1],Y,'r')
pylab.plot(X,Y_predict,'b-')
pylab.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到批量梯度下降图打印在屏幕上。
scikit learn batch gradient descent
阅读: Scikit 学习岭回归
Scikit 学习迷你批次梯度下降
在本节中，我们将了解 Scikit 如何在 python 中学习 minibatch 渐变下降的工作方式。
- sci kit learn mini batch gradient descent 是 gradient descent 的替代方法，它将大型数据集分成小批，并计算模型的误差。
- Minibatch 梯度下降可以轻松快速地更新参数。如果批量较大，更新模型时噪音较小。
代码:
在下面的代码中，我们将导入一些库，从中我们可以制作一个 minibatch 梯度下降图。
- data = num . random . multivarial _ normal(mean，cov，8000) 用于创建数据。
- plot.scatter(data[:600，0]，data[:600，1]，marker = ' . ')用于绘制或可视化数据。
- data = num . h stack((num . ones((data . shape[0]，2))，data)) 用于将输入数组的序列按列堆叠。
- X_train = data[:split，:-1] 用于将数据集拆分成训练数据。
- X_test = data[split:，-1] 用于将数据集拆分成测试数据。
- print(" Number of training set = % d " %(X _ train . shape[0])用于打印训练数据集的数量。
- print(" Number of testing set = % d " %(X _ test . shape[0])用于打印测试数据集的数量。
import numpy as num
import matplotlib.pyplot as plot
mean = num.array([6.0, 7.0])
cov = num.array([[2.0, 0.97], [0.97, 1.3]])
data = num.random.multivariate_normal(mean, cov, 8000)
plot.scatter(data[:600, 0], data[:600, 1], marker = '.')
plot.show()
data = num.hstack((num.ones((data.shape[0], 2)), data))
split_factor = 0.95
split = int(split_factor * data.shape[0])
X_train = data[:split, :-1]
y_train = data[:split, -1].reshape((-1, 1))
X_test = data[split:, :-1]
y_test = data[split:, -1].reshape((-1, 1))
print("Number of training set = % d"%(X_train.shape[0]))
print("Number of testing set = % d"%(X_test.shape[0]))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上绘制了带有图形的训练和测试集的数量。
scikit learn minibatch gradient descent
阅读: Scikit 学习随机森林
Scikit 学习逻辑回归梯度下降
在本节中，我们将了解 Scikit 如何学习逻辑回归梯度下降在 python 中的工作方式。
- Scikit learn 逻辑回归梯度下降是一个解决分类问题的过程，离散变量是一个结果。
- 梯度下降被定义为最小化模型损失或误差的优化算法。
代码:
在下面的代码中，我们将导入一些库，从中我们可以进行逻辑回归梯度下降。
- 数据集来源——https://www.kaggle.com/rakeshrau/social-network-ads从此处下载数据集。
data = PDS . read _ CSV(" dataa . CSV ")用于加载数据集。- plot.scatter(data['Age']，data['Purchased']) 用于绘制或可视化数据集。
- X_train，X_test，y_train，y _ test = train _ test _ split(data[' Age ']，data['Purchased']，test_size=0.20) 用于将数据集分为训练集和测试集。
- y_pred = predict(X，b1，b2) 用于预测模型。
- d _ b1 =-2 * sum((Y–Y _ pred) Y _ pred *(1–Y _ pred))*用于推导相对于 B1 的损失。
- d _ b2 =-2 * sum(X (Y–Y _ pred) Y _ pred *(1–Y _ pred))用于推导关于 B2 的损失。
- b0，b1 = logistic_regression(X_train，y_train) 用于训练模型。
- y_pred = predict(X_test_norm，b0，b1) 用于进行预测。
- plot.scatter(X_test，y_pred，c="red") 用于绘制图形。
- print(f " Accuracy = { Accuracy/len(y _ pred)} "用于打印精度。
import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from math import exp
plot.rcParams["figure.figsize"] = (12, 8)
data = pds.read_csv("dataa.csv")
data.head()
plot.scatter(data['Age'], data['Purchased'])
plot.show()
X_train, X_test, y_train, y_test = train_test_split(data['Age'], data['Purchased'], test_size=0.20)
def normalize(X):
return X - X.mean()
**# Method to make predictions**
def predict(X, b1, b2):
return num.array([1 / (1 + exp(-1*b1 + -1*b2*x)) for x in X])
def logistic_regression(X, Y):
X = normalize(X)
**# Initializing variables**
b1 = 0
b2 = 0
l = 0.001
epochs = 350
for epoch in range(epochs):
y_pred = predict(X, b1, b2)
d_b1 = -2 * sum((Y - y_pred) * y_pred * (1 - y_pred))
d_b2 = -2 * sum(X * (Y - y_pred) * y_pred * (1 - y_pred))
** # Update b1 and b2**
b1 = b1 - l * d_b1
b2 = b2 - l * d_b2
return b0, b1
b0, b1 = logistic_regression(X_train, y_train)
X_test_norm = normalize(X_test)
y_pred = predict(X_test_norm, b0, b1)
y_pred = [1 if p >= 0.7 else 0 for p in y_pred]
plot.clf()
plot.scatter(X_test, y_test)
plot.scatter(X_test, y_pred, c="red")
plot.show()
accuracy = 0
for i in range(len(y_pred)):
if y_pred[i] == y_test.iloc[i]:
accuracy += 1
print(f"Accuracy = {accuracy / len(y_pred)}")
输出:
运行上面的代码后，我们得到下面的输出，可以看到屏幕上打印了逻辑回归图和准确度分数。
Scikit learn Logistic regression gradient descent
阅读: Scikit 学习功能选择
Scikit 学习梯度下降线性回归
在这一节中，我们将学习关于 scikit 学习梯度回归线性回归 在 python 中的作品。
- 线性回归被定义为线性系统，线性回归的系数使用线性代数计算。
- 梯度下降线性回归也是一种优化算法，可以最小化模型的损失和误差。
代码:
在下面的代码中，我们将 numpy 作为 num 导入，以找到线性回归梯度下降模型。
a = 0是直线的截距。m = 7是直线的斜率。num.random.seed(45)用于生成随机数。- classifier.fit_model(x，y) 用于拟合模型。
- plot.plot(x，classifier . predict _ model(x))用于绘制图形。
- plot.title("梯度下降线性回归")用于给图加标题。
import numpy as num
class GradientDescentLinearRegression:
def __init__(self, learning_rate=0.02, iterations=1000):
self.learning_rate, self.iterations = learning_rate, iterations
def fit_model(self, x, y):
a = 0
m = 7
n = x.shape[0]
for _ in range(self.iterations):
a_gradient = -2 * num.sum(y - m*x + a) / n
m_gradient = -2 * num.sum(x*(y - (m*x + a))) / n
a = a + (self.learning_rate * a_gradient)
m = m - (self.learning_rate * m_gradient)
self.m, self.a = m, a
def predict_model(self, X):
return self.m*X + self.a
num.random.seed(45)
x = num.array(sorted(list(range(5))*20)) + num.random.normal(size=100, scale=0.10)
y = num.array(sorted(list(range(5))*20)) + num.random.normal(size=100, scale=0.20)
classifier = GradientDescentLinearRegression()
classifier.fit_model(x, y)
import matplotlib.pyplot as polt
plot.scatter(x, y, color='red')
plot.plot(x, classifier.predict_model(x))
plot.title("Gradient Descent Linear Regression")
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上绘制了梯度下降线性回归图。
scikit gradient decent linear regression
您可能还想阅读 Scikit learn 上的以下教程。
因此，在本教程中，我们讨论了sci kit learn gradient descent，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习梯度下降
- Scikit 学习梯度下降回归
- Scikit 学习随机梯度下降分类器
- Scikit 学习批次梯度下降
- Scikit 学习迷你批次梯度下降
- Scikit 学习随机梯度下降回归
- Scikit 学习逻辑回归梯度下降
- Scikit 学习梯度下降线性回归
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习隐马尔可夫模型
原文：https://pythonguides.com/scikit-learn-hidden-markov-model/
在这个 Python 教程中，我们将学习如何在 python 中创建一个 scikit learn Markov 模型，我们还将涵盖这些与 Markov 模型相关的例子。我们将讨论这些话题。
- 什么是 scikit learn 马尔可夫模型？
- 是什么让 scikit 学会了马尔可夫模型隐藏
- Scikit 学习隐马尔可夫模型示例
目录
什么是 scikit 学习马尔可夫模型？
在本节中，我们将了解 python 中的 Scikit learn 马尔可夫模型及其工作原理。
马尔可夫模型被定义为随机过程，而未来状态的考虑概率取决于当前过程状态。
举例:
假设你想建立一个模型，在给定猫当前状态的情况下，我们的猫处于三态的概率。
我们认为我们的猫很懒。我们定义它的状态睡觉，吃饭，便便。我们将初始概率分别设为 45%、35%和 20%。
代码:
import numpy as np
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plot
%matplotlib inline
states = ['sleeping', 'eating', 'pooping']
pi = [0.45, 0.35, 0.2]
state_space = pd.Series(pi, index=states, name='states')
print(state_space)
print(state_space.sum())
运行上面的代码后，我们得到下面的输出，其中我们可以看到猫的假设状态的概率。
scikit learn Markov model prediction
下一步是定义简单地处于相同状态或移动到给定当前状态的不同状态的概率。
q_df = pd.DataFrame(columns=states, index=states)
q_df.loc[states[0]] = [0.4, 0.2, 0.4]
q_df.loc[states[1]] = [0.40, 0.40, 0.2]
q_df.loc[states[2]] = [0.40, 0.20, .4]
print(q_df)
q_f = q_df.values
print('\n', q_f, q_f.shape, '\n')
print(q_df.sum(axis=1))
scikit learn Markov model transition process
完成上述过程后，我们有了初始概率和转移概率，现在我们使用 Networkx 包创建一个马尔可夫图。
from pprint import pprint
def _get_markov_edges(Q):
edge = {}
for column in Q.columns:
for index in Q.index:
edge[(index,column)] = Q.loc[index,column]
return edge
edge_wt = _get_markov_edges(q_df)
pprint(edge_wt)
scikit learn Markov model using networkx
现在我们可以创建一个 scikit 学习马尔可夫模型图。
graph . add _ nodes _ from(States)用于创建状态对应的节点。- Graph.add_edge(tmp_origin，tmp_destination，weight=v，label=v) 边代表转移概率。
Graph = nx.MultiDiGraph()
Graph.add_nodes_from(states)
print(f'Nodes:\n{Graph.nodes()}\n')
for k, v in edge_wt.items():
tmp_origin, tmp_destination = k[0], k[1]
Graph.add_edge(tmp_origin, tmp_destination, weight=v, label=v)
print(f'Edges:')
pprint(Graph.edges(data=True))
position = nx.drawing.nx_pydot.graphviz_layout(Graph, prog='dot')
nx.draw_networkx(Graph, position)
edge_labels = {(n1,n2):d['label'] for n1,n2,d in Graph.edges(data=True)}
nx.draw_networkx_edge_labels(Graph , position, edge_labels=edge_labels)
nx.drawing.nx_pydot.write_dot(Graph, 'pet_dog_markov.dot')
Scikit learn Markov model graph
是什么让 scikit 学会了马尔科夫模型隐藏
在本节中，我们将了解隐藏的 scikit 学习模型以及谁隐藏了马尔可夫模型。
考虑到我们的猫行为怪异，我们发现它们为什么会这样，我们的猫的行为是由于疾病，或者仅仅是它们这样做。
代码:
在这里，我们创造了一个空间，可以看到我们的猫是健康的还是生病的。
hidden_state = ['healthy', 'sick']
pi = [0.55, 0.45]
state_space = pd.Series(pi, index=hidden_state, name='states')
print(state_space)
print('\n', state_space.sum())
scikit learn Markov hidden state space
下一步，我们将为隐藏状态创建一个转换矩阵。
a1_df = pd.DataFrame(columns=hidden_state, index=hidden_state)
a1_df.loc[hidden_state[0]] = [0.7, 0.3]
a1_df.loc[hidden_state[1]] = [0.4, 0.6]
print(a1_df)
a1 = a1_df.values
print('\n', a1, a1.shape, '\n')
print(a1_df.sum(axis=1))
scikit learn transition matrix hidden state
在这一步，我们创建一个发射和观察矩阵。我们创建的矩阵是 axb 的大小。a 是隐藏状态的数量，b 是可观察状态的数量。
observable_state = states
b1_df = pd.DataFrame(columns=observable_state, index=hidden_state)
b1_df.loc[hidden_state[0]] = [0.3, 0.5, 0.2]
b1_df.loc[hidden_state[1]] = [0.3, 0.3, 0.4]
print(b1_df)
b1 = b1_df.values
print('\n', b1, b1.shape, '\n')
print(b1_df.sum(axis=1))
scikit learn emission and observable matrix
在这一步中，我们将创建图形边和图形对象，从中我们可以创建一个完整的图形。
hide_edges_wt = _get_markov_edges(a1_df)
pprint(hide_edges_wt)
emit_edges_wt = _get_markov_edges(b1_df)
pprint(emit_edges_wt)
scikit learn hidden state graph
这里我们可以画出隐马尔可夫模型的完整图形。
G = nx.MultiDiGraph()
G.add_nodes_from(hidden_state)
print(f'Nodes:\n{G.nodes()}\n')
for k, v in hide_edges_wt.items():
tmp_origin, tmp_destination = k[0], k[1]
G.add_edge(tmp_origin, tmp_destination, weight=v, label=v)
for k, v in emit_edges_wt.items():
tmp_origin, tmp_destination = k[0], k[1]
G.add_edge(tmp_origin, tmp_destination, weight=v, label=v)
print(f'Edges:')
pprint(G.edges(data=True))
pos = nx.drawing.nx_pydot.graphviz_layout(G, prog='neato')
nx.draw_networkx(G, pos)
scikit learn Markov hidden model
阅读: Scikit 学习决策树
Scikit 学习隐马尔可夫模型示例
在本节中，我们将了解 scikit 在 python 中学习隐马尔可夫模型的例子。
scikit 学习隐马尔可夫模型是一个过程，而未来的未来概率取决于当前状态。
代码:
在下面的代码中，我们将导入一些库，并从中创建一个隐马尔可夫模型。
状态空间= pd。系列(pi，index=states，name='states') 用于创建状态空间和初始状态空间概率。
edge[(index，column)] = Q.loc[index，column] 用于创建映射转移概率数据帧的函数。
graph . add _ nodes _ from(States)**用于添加数据**帧对应的节点。
Graph.add_edge(tmp_origin，tmp_destination，weight=v，label=v) edges 用于表示过渡属性。
import numpy as np
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plot
%matplotlib inline
states = ['sleeping', 'eating', 'pooping']
pi = [0.45, 0.35, 0.2]
state_space = pd.Series(pi, index=states, name='states')
print(state_space)
print(state_space.sum())
q_df = pd.DataFrame(columns=states, index=states)
q_df.loc[states[0]] = [0.4, 0.2, 0.4]
q_df.loc[states[1]] = [0.40, 0.40, 0.2]
q_df.loc[states[2]] = [0.40, 0.20, .4]
print(q_df)
q_f = q_df.values
print('\n', q_f, q_f.shape, '\n')
print(q_df.sum(axis=1))
from pprint import pprint
def _get_markov_edges(Q):
edge = {}
for column in Q.columns:
for index in Q.index:
edge[(index,column)] = Q.loc[index,column]
return edge
edge_wt = _get_markov_edges(q_df)
pprint(edge_wt)
Graph = nx.MultiDiGraph()
Graph.add_nodes_from(states)
print(f'Nodes:\n{Graph.nodes()}\n')
for k, v in edge_wt.items():
tmp_origin, tmp_destination = k[0], k[1]
Graph.add_edge(tmp_origin, tmp_destination, weight=v, label=v)
print(f'Edges:')
pprint(Graph.edges(data=True))
position = nx.drawing.nx_pydot.graphviz_layout(Graph, prog='dot')
nx.draw_networkx(Graph, position)
edge_labels = {(n1,n2):d['label'] for n1,n2,d in Graph.edges(data=True)}
nx.draw_networkx_edge_labels(Graph , position, edge_labels=edge_labels)
nx.drawing.nx_pydot.write_dot(Graph, 'pet_dog_markov.dot')
输出:
运行上面的代码后，我们得到下面的输出，可以看到 Markov 模型被绘制在屏幕上。
scikit learn hidden Markov model
您可能还想阅读以下 Scikit 学习教程。
因此，在本教程中，我们讨论了sci kit learn hidden Markov model，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 scikit learn 马尔可夫模型？
- 是什么让 scikit 学会了马尔可夫模型隐藏
- Scikit 学习隐马尔可夫模型的例子。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习隐藏层尺寸
原文：https://pythonguides.com/scikit-learn-hidden_layer_sizes/
在这个Python 教程中，我们将学习scikit 如何在 Python 中学习 hidden _ layer _ sizes的工作原理，我们还将涵盖与 hidden_layers_sizes 相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习隐藏层尺寸
- Scikit 学习 hidden _ layer _ sizes 示例
目录
Scikit 学习 hidden _ layer _ size
在本节中，我们将了解 scikit learn hidden_layer_sizes 如何在 Python 中工作。Scikit learnhidden _ layer _ sizes 定义为一个参数，允许我们设置神经网络分类器中的层数和节点数。
代码:
在下面的代码中，我们将从 sklearn.datasets 导入 make _ blobs，通过它我们可以设置层数和节点数。
n_samples = 200 用于设置样本数。
fig，axis = plot.subplots() 是用来在屏幕上绘制图形的 subplot。
import matplotlib.pyplot as plot
from sklearn.datasets import make_blobs
n_samples = 200
blob_centers = ([1, 1], [3, 4], [1, 3.3], [3.5, 1.8])
data, labels = make_blobs(n_samples = n_samples,
centers = blob_centers,
cluster_std = 0.5,
random_state = 0)
colours = ('red', 'blue', "green", "orange")
fig, axis = plot.subplots()
for n_class in range(len(blob_centers)):
axis.scatter(data[labels == n_class][: , 0],
data[labels == n_class][: , 1],
c = colours[n_class],
s = 30,
label = str(n_class))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上绘制了散点。
scikit learn hidden_layer_sizes
另外，检查: Scikit 学习岭回归
Scikit 学习 hidden_layer_sizes 示例
在本节中，我们将了解 scikit 如何在 Python 中学习 hidden_layer_sizes 示例。
神经网络中的 hidden_layer_sizes 作为一个参数，允许我们设置层数。
例 1:
在下面的代码中，我们将从 sklearn.model_selection 导入 tain_test_aplit，通过它我们可以拆分训练和测试数据集。
X = pd。DataFrame(cal_housing.data，columns = cal _ housing . feature _ names)用于创建数据集。
X_train，X_test，y_train，y_test = train_test_split(X，y，test_size=0.1，random_state=0) 用于拆分训练和测试数据。
est = make _ pipeline(quantile transformer()、MLPRegressor(hidden_layer_sizes =(30，15)、learning_rate_init=0.01、early_stopping=True、random_state=0)，用于制作管道，在这里面我们给出 hidden _ layer _ sizes。
import pandas as pds
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
calhousing = fetch_california_housing()
x = pds.DataFrame(calhousing.data, columns=calhousing.feature_names)
y = calhousing.target
y -= y.mean()
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)
from time import time
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import QuantileTransformer
from sklearn.neural_network import MLPRegressor
print("Train MLPRegressor")
tim = time()
estm = make_pipeline(
QuantileTransformer(),
MLPRegressor(
hidden_layer_sizes=(40, 25),
learning_rate_init=0.02,
early_stopping=True,
random_state=0,
),
)
estm.fit(x_train, y_train)
print(f"done in {time() - tim:.4f}s")
print(f"Testing R2 score: {estm.score(x_test, y_test):.2f}")
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到测试分数被打印在屏幕上。
scikit learn hidden_layer_sizes example
例 2:
在下面的代码中，我们将从 sklearn.inspection 导入 partial _ dependence，通过它我们可以计算部分依赖图。
- displays.figure_。suptitle("房屋价值对非位置特征的部分依赖性\n " "对于加利福尼亚住房数据集，使用 mlpre pressor ")用于显示图形子标题。
- displays.figure_。subplots _ adjust(hspace = 0.3)用于绘制图形。
import matplotlib.pyplot as plt
from sklearn.inspection import partial_dependence
from sklearn.inspection import PartialDependenceDisplay
print("Compute partial dependence plots...")
tim = time()
features = ["MedInc", "AveOccup", "HouseAge", "AveRooms"]
displays = PartialDependenceDisplay.from_estimator(
est,
X_train,
features,
kind="both",
subsample=50,
n_jobs=3,
grid_resolution=20,
random_state=0,
ice_lines_kw={"color": "tab:green", "alpha": 0.2, "linewidth": 0.5},
pd_line_kw={"color": "tab:red", "linestyle": "--"},
)
print(f"done in {time() - tim:.3f}s")
displays.figure_.suptitle(
"Partial dependence of house value on non-location features\n"
"for the California housing dataset, with MLPRegressor"
)
displays.figure_.subplots_adjust(hspace=0.3)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制了 California housing 数据集的房价对非位置要素的部分依赖关系。
scikit learn hidden_layer_sizes examples
您可能还想阅读以下 Scikit 学习教程。
因此，在本教程中，我们讨论了Scikit learn hidden _ layer _ sizes，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习隐藏层尺寸
- Scikit 学习 hidden _ layer _ sizes 示例
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习层次聚类
原文：https://pythonguides.com/scikit-learn-hierarchical-clustering/
在本 Python 教程中，我们将学习如何让 Scikit 学习 Python 中的层次聚类，我们还将涵盖与层次聚类相关的不同示例。我们将讨论这些话题。
- Scikit 学习层次聚类
- Scikit 学习分层聚类示例
- Scikit 了解分层聚类功能
- Scikit 学习层次聚类树状图
- Scikit 学习层次聚类链接
- Scikit 学习层次分类
目录
Scikit 学习层次聚类
在本节中，我们将了解如何让 scikit 学习 python 中的层次聚类。
分层聚类的定义是，它是一种将相似对象分类成组的算法。
集群的端点是一组集群，并且每个集群都不同于其他集群。
代码:
在下面的代码中，我们将导入一些库 import time 作为 time ， import numpy 作为 np ， import matplotlib.pyplot 作为 plot ，从中我们定义数据的结构。
-
print(" Compute structured hierarchical clustering…)用于计算聚类并在屏幕上打印。
-
plot.figure()用于在屏幕上绘制图形。 -
p3。Axes3D(fig) 用于在屏幕上绘制 3d fig。
-
plot . title(" With connectivity constraints(time % . 2fs)" % elapsed _ time)用来给图加标题。
import time as time
import numpy as np
import matplotlib.pyplot as plot
import mpl_toolkits.mplot3d.axes3d as p3
from sklearn.cluster import AgglomerativeClustering
from sklearn.datasets import make_swiss_roll
connectivity = kneighbors_graph(X, n_neighbors=12, include_self=False)
print("Compute structured hierarchical clustering...")
st = time.time()
ward = AgglomerativeClustering(
n_clusters=8, connectivity=connectivity, linkage="ward"
).fit(X)
elapsed_time = time.time() - st
label = ward.labels_
print("Elapsed time: %.2fs" % elapsed_time)
print("Number of points: %i" % label.size)
fig = plot.figure()
axis = p3.Axes3D(fig)
axis.view_init(8, -90)
for l in np.unique(label):
axis.scatter(
X[label == l, 0],
X[label == l, 1],
X[label == l, 2],
color=plt.cm.jet(float(l) / np.max(label + 1)),
s=20,
edgecolor="k",
)
plot.title("With connectivity constraints (time %.2fs)" % elapsed_time)
plot.show()
输出:
运行上面的代码后，我们得到了下面的输出，从中我们可以看到层次聚类是通过约束的连通性完成的。
scikit learn hierarchical clustering
Scikit 学习层次聚类示例
在本节中，我们将学习如何让 scikit 学习 python 中的层次聚类示例。
- 众所周知，层次聚类将相似的对象分成不同的组。它将每个集群视为一个单独的集群。
- 它识别彼此非常接近的两个集群。合并两个最相似的聚类。
代码:
在下面的代码中，我们将导入一些库，从中我们可以绘制层次聚类图。
X = np.array()用于创建数据集。- from sklearn.cluster 导入聚合集群用于从集群导入类。
clusters.fit_predict(X)用于预测每个数据点所属的聚类。- plt.scatter(X[:，0]，X[:，1]，c=clusters.labels_，cmap='rainbow') 用于在屏幕上绘制聚类。
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
import numpy as np
X = np.array([[10,3],
[15,15],
[20,12],
[30,10],
[35,30],
[40,70],
[45,80],
[50,78],
[55,55],
[60,91],])
from sklearn.cluster import AgglomerativeClustering
clusters = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')
clusters.fit_predict(X)
print(clusters.labels_)
plt.scatter(X[:,0],X[:,1], c=clusters.labels_, cmap='rainbow')
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到显示了两个集群组，前五个集群在一起，后五个集群在一起。
scikit learn hierarchical clustering example
Read Scikit-learn Vs Tensorflow
Scikit 学习层次聚类特性
在本节中，我们将了解 python 中的 scikit learn 层次聚类特性。
python 中 sci kit learn hierarchical clusterin 的主要特性有:
- 删除问题
- 数据层次
- 通过指针分级
- 最小化磁盘输入和输出
- 快速导航
- 记录之间的预定义关系
- 难以重组
- 删除问题:删除问题发生在父集群被删除，然后子集群被自动删除，因为子集群连接到父集群。
2.数据层次:层次聚类的所有数据都表示为一棵层次树。
3.通过指针的层次结构:指针用于链接记录。指针指出哪条记录是父记录，哪条是子记录。
4.最小化磁盘输入和输出:父子记录在存储设备上存储得非常接近，这样可以最小化硬盘输入和输出。
5.快速导航:父节点与子节点之间的距离非常小，这就是数据性能得以提高的原因。并且在数据库中导航非常快。
6.记录间的预定义关系:所有的关系都是预定义的。在层次聚类中，所有的根节点、父节点都是在数据库中预定义的。
7.难以重组:在分层集群中，由于父子关系，很难重组数据库。子节点连接到父节点，如果我们重新组织数据，父节点和子节点之间的关系会变得不匹配。
阅读 Scikit 学习决策树
Scikit 学习层次聚类树状图
本节我们将学习如何用 python 让 scikit 学习层次聚类树状图。
分层聚类用于构建聚类树来表示数据，其中每个聚类与最近的相似节点相链接，并形成一个树状图。
代码:
在下面的代码中，我们将导入一些库 import numpy as np ，从 matplotlib 导入 pyplot as plot ，从 scipy.cluster.hierarchy 导入树状图由此我们构建了一个树状图。
- **树状图(linkagematrix，
kwargs)用于绘制树状图。 - model = agglomerate clustering(distance_threshold = 0，n_clusters=None) 用于设置 distance _ threshold 以确保我们完成完整的树。
- plot_dendrogram(model，truncate_mode="level "，p=3) 用于绘制树状图的前三级。
import numpy as np
from matplotlib import pyplot as plot
from scipy.cluster.hierarchy import dendrogram
from sklearn.datasets import load_iris
from sklearn.cluster import AgglomerativeClustering
def plot_dendrogram(model, **kwargs):
count = np.zeros(model.children_.shape[0])
nsamples = len(model.labels_)
for i, merge in enumerate(model.children_):
currentcount = 0
for child_idx in merge:
if child_idx < nsamples:
currentcount += 1
else:
currentcount += count[child_idx - nsamples]
count[i] = currentcount
linkagematrix = np.column_stack(
[model.children_, model.distances_, count]
).astype(float)
dendrogram(linkagematrix, **kwargs)
iris = load_iris()
X = iris.data
model = AgglomerativeClustering(distance_threshold=0, n_clusters=None)
model = model.fit(X)
plot.title("Hierarchical Clustering Dendrogram")
plot_dendrogram(model, truncate_mode="level", p=3)
plot.xlabel("Number of points in node (or index of point if no parenthesis).")
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上显示了一个树状图。
scikit learn hierarchical clustering dendrogram
Scikit 学习层次聚类联动
在这一节中，我们将学习 python 中的 scikit learn 层次聚类链接。
分层聚类用于构建聚类树来表示数据，其中每个聚类与最近的相似节点相链接。
在层次链接聚类中，两个聚类之间的链接是两点之间的最长距离。
代码:
在下面的代码中，我们将从 scipy 导入树图、链接，还将从 matplotlib 导入 pyplot 作为 plot。
我们可以在两个集群之间创建一个 ward 链接，并绘制该集群的图形。
from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plot
x = [[i] for i in [4, 12, 0, 6, 1, 11, 11, 0]]
Z = linkage(x, 'ward')
figure = plot.figure(figsize=(25, 10))
den = dendrogram(Z)
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上绘制了一个 ward clusters 树状图。
scikit learn hierarchical clustering ward linkage
在这里，我们可以在两个集群之间创建一个链接集群，并绘制这些集群的图形。
Z = linkage(x, 'single')
figure = plot.figure(figsize=(25, 10))
den = dendrogram(Z)
plot.show()
运行上面的代码后，我们得到了下面的输出，其中我们可以看到以树形图的形式创建了一个链接。
scikit learn hierarchical clustering single linkage
阅读: Scikit 学习线性回归
Scikit 学习层次分类
在本节中，我们将学习 python 中的scikit learn hierarchical class ification。
等级分类被定义为根据等级或顺序对事物进行聚类的系统。
代码:
在这段代码中，我们将导入一些库，从中我们可以创建分类器并进行分层分类。
- 标准定标器()。fit _ transform(x)用于拟合数据。
- x_train，x_test，y_train，y_test = train_test_split(x，y，test_size=0.4，random_state=42) 它是一个预处理数据集，将
the 数据拆分为训练和测试部分。 - ax.scatter(x_train[:，0]，x_train[:，1]，c=y_train，cmap=cm_bright，edgecolors="k") 它只是绘制训练点。
- ax.scatter(x_test[:，0]，x_test[:，1]，c=y_test，cmap=cm_bright，alpha=0.6，edgecolors="k") 它只是绘制测试点。
import numpy as np
import matplotlib.pyplot as plot
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
h = 0.02
classifiernames = [
"Nearest Neighbors",
"Linear SVM",
"RBF SVM",
"Gaussian Process",
"Decision Tree",
"Random Forest",
"Neural Net",
"AdaBoost",
"Naive Bayes",
"QDA",
]
classifiers = [
KNeighborsClassifier(3),
SVC(kernel="linear", C=0.025),
SVC(gamma=2, C=1),
GaussianProcessClassifier(1.0 * RBF(1.0)),
DecisionTreeClassifier(max_depth=5),
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
MLPClassifier(alpha=1, max_iter=1000),
AdaBoostClassifier(),
GaussianNB(),
QuadraticDiscriminantAnalysis(),
]
x, y = make_classification(
n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1
)
rng = np.random.RandomState(2)
x += 2 * rng.uniform(size=x.shape)
linearly_separable = (x, y)
datasets = [
make_moons(noise=0.3, random_state=0),
make_circles(noise=0.2, factor=0.5, random_state=1),
linearly_separable,
]
figure = plot.figure(figsize=(27, 9))
i = 1
for ds_cnt, ds in enumerate(datasets):
x, y = ds
x = StandardScaler().fit_transform(x)
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=0.4, random_state=42
)
x_min, x_max = x[:, 0].min() - 0.5, x[:, 0].max() + 0.5
y_min, y_max = x[:, 1].min() - 0.5, x[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
cm = plot.cm.RdBu
cm_bright = ListedColormap(["#FF0000", "#0000FF"])
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
if ds_cnt == 0:
ax.set_title("Input data")
ax.scatter(x_train[:, 0], x_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k")
ax.scatter(
x_test[:, 0], x_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6, edgecolors="k"
)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
i += 1
for name, clf in zip(classifiernames, classifiers):
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
clf.fit(x_train, y_train)
score = clf.score(x_test, y_test)
if hasattr(clf, "decision_function"):
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
else:
Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=cm, alpha=0.8)
# Plot the training points
ax.scatter(
x_train[:, 0], x_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k"
)
ax.scatter(
x_test[:, 0],
x_test[:, 1],
c=y_test,
cmap=cm_bright,
edgecolors="k",
alpha=0.6,
)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
if ds_cnt == 0:
ax.set_title(name)
ax.text(
xx.max() - 0.3,
yy.min() + 0.3,
("%.2f" % score).lstrip("0"),
size=15,
horizontalalignment="right",
)
i += 1
plot.tight_layout()
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上的分类已经完成。
scikit learn hierarchical classification
另外，看看 scikit learn 上的更多教程。
因此，在本教程中，我们讨论了sci kit learn hierarchical clustering，我们还介绍了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习层次聚类
- Scikit 学习分层聚类示例
- Scikit 了解分层聚类功能
- Scikit 学习层次聚类树状图
- Scikit 学习层次聚类链接
- Scikit 学习层次分类
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习超参数调谐
原文：https://pythonguides.com/scikit-learn-hyperparameter-tuning/
在本 Python 教程中，我们将学习 Scikit learn 超参数调优，我们还将使用 Scikit learn 涵盖与超参数调优相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习超参数调谐
- Scikit 学习随机森林超参数
- Scikit 学习逻辑回归超参数调整
- Scikit 学习神经网络超参数调整
- Scikit 学习线性回归超参数
- Scikit 学习 SVM 超参数
- Scikit 学习超参数估计
- Scikit 学习超参数优化
目录
- Scikit 学习超参数调整
- Scikit 学习随机森林超参数
- Scikit 学习逻辑回归超参数整定
- Scikit 学习神经网络超参数整定
- Scikit 学习线性回归超参数
- Scikit 学习 SVM 超参数
- Scikit 学习超参数估计
- Scikit 学习超参数优化
Scikit 学习超参数调整
在本节中，我们将了解 python 中的 scikit learn 超参数调优工作。
超参数调整被定义为作为参数传递给估计器类的构造函数的参数。
代码:
- 在下面的代码中，我们将从 sklearn.utils.fixes 导入 loguniform，通过它我们比较超参数估计的随机搜索和网格搜索。
- load_digits(return_X_y=True，n_class=3) 用于加载数据。
- clf = SGD classifier(loss = " hinge "，penalty="elasticnet "，fit_intercept=True) 用于构建分类器。
- random _ search = RandomizedSearchCV(clf，param_distributions=param_dist，n_iter=n_iter_search) 用于运行随机大小。
- grid _ search = GridSearchCV(clf，param_grid=param_grid) 用于运行网格搜索。
import numpy as np
from time import time
import scipy.stats as stats
from sklearn.utils.fixes import loguniform
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.datasets import load_digits
from sklearn.linear_model import SGDClassifier
x, y = load_digits(return_X_y=True, n_class=3)
clf = SGDClassifier(loss="hinge", penalty="elasticnet", fit_intercept=True)
def report(results, n_top=3):
for i in range(1, n_top + 1):
candidate = np.flatnonzero(results["rank_test_score"] == i)
for candidate in candidate:
print("Model with rank: {0}".format(i))
print(
"Mean validation score: {0:.3f} (std: {1:.3f})".format(
results["mean_test_score"][candidate],
results["std_test_score"][candidate],
)
)
print("Parameters: {0}".format(results["params"][candidate]))
print("")
param_dist = {
"average": [True, False],
"l1_ratio": stats.uniform(0, 1),
"alpha": loguniform(1e-2, 1e0),
}
n_iter_search = 15
random_search = RandomizedSearchCV(
clf, param_distributions=param_dist, n_iter=n_iter_search
)
start = time()
random_search.fit(x, y)
print(
"RandomizedSearchCV took %.2f seconds for %d candidates parameter settings."
% ((time() - start), n_iter_search)
)
report(random_search.cv_results_)
param_grid = {
"average": [True, False],
"l1_ratio": np.linspace(0, 1, num=10),
"alpha": np.power(10, np.arange(-2, 1, dtype=float)),
}
grid_search = GridSearchCV(clf, param_grid=param_grid)
start = time()
grid_search.fit(x, y)
print(
"GridSearchCV took %.2f seconds for %d candidate parameter settings."
% (time() - start, len(grid_search.cv_results_["params"]))
)
report(grid_search.cv_results_)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到在屏幕上对超参数的随机搜索和网格搜索进行了比较。
scikit learn hyperparameter tuning
另外，请阅读: Scikit-learn Vs Tensorflow
Scikit 学习随机森林超参数
在本节中，我们将了解 scikit 在 python 中学习随机森林超参数的工作方式。
在 scikit 中，学习超参数包括决策树的数量和在节点分裂时通过分裂每棵树所考虑的特征的数量。
代码:
在下面的代码中，我们将从 sklearn.ensemble 中导入 RandomForestRegressor，通过它我们可以看到当前使用的超参数。
from sklearn.ensemble import RandomForestRegressor
rf = RandomForestRegressor(random_state = 42)
from pprint import pprint
print('Hyperparameters currently in use:\n')
pprint(rf.get_params())
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到当前使用的超参数被打印在屏幕上。
scikit learn random forest hyperparameter tuning
Scikit 学习逻辑回归超参数整定
在本节中，我们将了解 python 中的 scikit learn 逻辑回归超参数调整。
- 逻辑回归是一种用于描述数据的预测性分析。它用于评估模型性能的指标，以决定最佳超参数。
- 代码:
- 在下面的代码中，我们将从 sklearn 导入 linear_model，通过它我们可以评估模型性能的度量，以决定最佳的超参数。
dataset = datasets . load _ wine()用于加载数据集。- 五氯苯甲醚=分解。PCA() 主成分分析用于降低特征维数。
- print('BestPenalty:'，clf_GS.best_estimator_。get _ params([' logistic _ Regression _ _ penalty '])用于在屏幕上打印最佳超参数。
import numpy as np
from sklearn import linear_model, decomposition, datasets
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
dataset = datasets.load_wine()
X = dataset.data
y = dataset.target
pca = decomposition.PCA()
logistic_Regression = linear_model.LogisticRegression()
pipe = Pipeline(steps=[('std_slc', std_slc),
('pca', pca),
('logistic_Regression', logistic_Regression)])
n_components = list(range(1,X.shape[1]+1,1))
C = np.logspace(-4, 4, 50)
penalty = ['l1', 'l2']
parameters = dict(pca__n_components=n_components,
logistic_Regression__C=C,
logistic_Regression__penalty=penalty)
clf_GS = GridSearchCV(pipe, parameters)
clf_GS.fit(X, y)
print('Best Penalty:', clf_GS.best_estimator_.get_params()['logistic_Regression__penalty'])
print('Best C:', clf_GS.best_estimator_.get_params()['logistic_Regression__C'])
print('Best Number Of Components:', clf_GS.best_estimator_.get_params()['pca__n_components'])
print(); print(clf_GS.best_estimator_.get_params()['logistic_Regression'])
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 hyperparameter 的最佳值被打印在屏幕上。
scikit learn logistic regression hyperparameter tuning
阅读: Scikit 学习决策树
Scikit 学习神经网络超参数整定
在本节中，我们将了解 scikit 如何在 python 中学习神经网络超参数调整。
神经网络超参数调整被定义为多个超参数，例如多个隐藏神经元。
代码:
在下面的代码中，我们将从 sklearn.neural_network 导入 MLPClassifier，通过它我们可以创建一个神经网络超参数调整。
from sklearn.neural_network import MLPClassifier
x = [[0., 0.], [1., 1.]]
y = [0, 1]
classifier = MLPClassifier(solver='lbfgs', alpha=1e-5,
hidden_layer_sizes=(5, 2), random_state=1)
classifier.fit(x, y)
classifier.predict([[2., 2.], [-1., -2.]])
[coef.shape for coef in clf.coefs_]
classifier.predict_proba([[2., 2.], [1., 2.]])
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到神经网络超参数调整打印在屏幕上。
scikit learn neural network hyperparameter tuning
Scikit 学习线性回归超参数
在本节中，我们将了解 scikit 如何在 python 中学习线性回归超参数的工作方式。
超参数是一个寻找理想模型架构的过程。scikit 学习线性回归是一种线性建模方法。
代码:
在下面的代码中，我们将导入 pandas 作为 pd，导入 numpy 作为 np 来创建模型。
diabetes = datasets . load _ diabetes()用于创建数据集。df.head()用于打印前五行。
import numpy as np
import pandas as pd
import matplotlib.pylab as plt
%matplotlib inline
import sklearn
from sklearn import datasets
diabetes = datasets.load_diabetes()
df=pd.DataFrame(diabetes.data)
df.columns= diabetes.feature_names
df['diabetes_measure']=diabetes.target
df.head()
运行上面的代码后，我们得到下面的输出，从中我们可以看到数据集的前五行被打印在屏幕上。
scikit learn linear regression hyperparameter dataset
- x=df.iloc[:，:-1] 用于创建特征矩阵 x
- y=df.iloc[:，-1] 用于创建响应向量 y
- b = x.iloc[:，2] 用于将数组整形为二维。
- 从 sklearn.linear_model 导入 LinearRegression 导入线性模型的 LinearRegression 类。
- plt.figure(figsize=(10，6)) 用于在散点图上绘制回归线。
x=df.iloc[:,:-1]
y=df.iloc[:,-1]
b = x.iloc[:,2]
b=b[:,np.newaxis]
y= df.iloc[:,-1]
y=y[:,np.newaxis]
from sklearn.linear_model import LinearRegression
simple_lr = LinearRegression()
simple_lr = LinearRegression().fit(b,y)
predicted_y = simple_lr.predict(b)
plt.figure(figsize=(10,6))
plt.scatter(b, y)
plt.plot(b, predicted_y, c='r')
plt.title('Scatter plot and a Simple Linear Regression Model')
plt.ylabel("y")
plt.xlabel("b")
plt.show()
运行上面的代码后，我们得到了下面的输出，其中我们可以看到屏幕上绘制了回归线。
scikit learn linear regression hyperparameter scatter plot
- 这里从 sklearn.model_selection 导入 cross_val_score 用于从 model_selection 导入 cross_val_score 函数。
- 而 cross_val_score(simple_lr，b，y，scoring = ' neg _ mean _ squared _ error '，cv=10) 用于在一个对象中存储十个分数。
from sklearn.model_selection import cross_val_score
mse= cross_val_score(simple_lr,b,y,scoring='neg_mean_squared_error',cv=10)
mse.mean()
运行上面的代码后，我们得到了下面的输出，其中我们可以看到模型的平均值显示了作为理想模型的线性回归。
scikit learn linear regression hyperparameter tuning
阅读: Scikit 学习层次聚类
Scikit 学习 SVM 超参数
在本节中，我们将了解 Scikit 如何在 Python 中学习 SVM 超参数的工作方式。
- 在前进之前，我们应该有一个关于 SVM 的知识。SVM 代表支持向量机。
- SVM 被用作个人观察的坐标。它用于分类和回归。
- SVM 超参数定义为一个参数，其值用于控制学习过程。
代码:
在下面的代码中，我们将从 sklearn.svm 中导入 SVC，作为个体观测的坐标。
超参数被定义为作为参数传递给估计器类的构造函数的参数。
base _ estimator = SVC(gamma = ' scale ')gamma 用于支持向量分类器。
from sklearn.datasets import make_classification
from sklearn.svm import SVC
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV
import pandas as pd
parameter_grid= {'kernel': ('linear', 'rbf'),
'C': [1, 10, 100]}
base_estimator = SVC(gamma='scale')
X, y = make_classification(n_samples=1000)
sh = HalvingGridSearchCV(base_estimator, parameter_grid, cv=5,
factor=2, min_resources=20).fit(X, y)
sh.n_resources_
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上打印了 scikit 学习 SVM 超参数资源。
scikit learn SVM hyperparameter
阅读: Scikit 学习随机森林
Scikit 学习超参数估计
在本节中，我们将学习 python 中的 scikit 学习超参数估计。
- 众所周知，超参数是作为参数传递给估计器的构造函数的参数。
- 超参数是不使用实际观测数据估计的模型参数。
代码:
在下面的代码中，我们将从 sklearn.datasets 中导入 make_classification，通过它在不使用实际观测数据的情况下估计模型参数。
这里sh = halvinggridsearchv(base _ estimator，parameter_grid，cv=5，factor=2，resource='n_estimators '，max_resources=30)。fit(x，y) 用于在不使用实际观测数据的情况下进行估计。
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV
import pandas as pd
parameter_grid = {'max_depth': [3, 5, 10],
'min_samples_split': [2, 5, 10]}
base_estimator = RandomForestClassifier(random_state=0)
x, y = make_classification(n_samples=1000, random_state=0)
sh = HalvingGridSearchCV(base_estimator, parameter_grid, cv=5,
factor=2, resource='n_estimators',
max_resources=30).fit(x, y)
sh.best_estimator_
输出:
在运行上面的代码之后，我们得到了下面的输出，其中我们可以看到模型的最佳估计被打印在屏幕上。
scikit learn hyperparameter estimation
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习超参数优化
在本节中，我们将学习 python 中的 scikit learn 超参数优化。
超参数优化被定义为选择一组最优超参数的过程或问题。
语法:
在这种语法中，估计器被优化以找到所有参数的名称和当前值。
estimator.get_parameter()
代码:
在下面的代码中，我们将从数据中导入 read_csv 来读取数据集，并使用 hyperparameter 来查找性能良好的模型配置。
- ' https:
//raw . githubusercontent . com/jbrownlee/Datasets/master/sonar . CSV '用于加载数据集。 data = dataframe.values用于分割输入和输出元素。
from pandas import read_csv
dataseturl = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
x, y = data[:, :-1], data[:, -1]
print(x.shape, y.shape)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 208 行数据和 60 个变量。
scikit learn hyperparameter optimization
您可能还想阅读以下 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit learn 超参数调整，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习超参数调谐
- Scikit 学习随机森林超参数
- Scikit 学习逻辑回归超参数调整
- Scikit 学习神经网络超参数调整
- Scikit 学习线性回归超参数
- Scikit 学习 SVM 超参数
- Scikit 学习超参数估计
- Scikit 学习超参数优化
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习图像处理
在本 Python 教程中，我们将学习 Scikit 学习映像，我们还将涵盖与 Scikit 学习映像相关的不同示例。我们将讨论这些话题。
- Scikit 学习图像相似性
- Scikit 学习图像聚类
- Scikit 学习图像增强
- Scikit 学习图像数据集
- Scikit 学习图像预处理
- Scikit 学习图像特征提取
- sci kit-学习图像分类
- Scikit 学习图像分割
- Scikit 学习图像识别
- Scikit 学习映像安装
- Scikit 学习图像读取图像
目录
- Scikit 学习图像相似度
- Scikit 学习图像聚类
- Scikit 学习图像增强
- Scikit 学习图像数据集
- Scikit 学习图像预处理
- Scikit 学习图像特征提取
- Scikit 学习图像分类
- Scikit 学会图像分割
- Scikit 学习图像识别
- Scikit 学习镜像安装
- Scikit 学习图像读取图像
Scikit 学习图像相似度
在本节中，我们将了解scikit 如何使用 python 学习图像相似性。
Scikit 学习图像相似度定义为估计两幅相同图像相似度的过程。
代码:
在下面的代码中，我们将从 skimage.metrics 导入 structural_similarity 作为 ssim，通过它我们可以估计图像的相似性。
image = img _ as _ float(data . camera())用于举例运行图像。range = num . random . default _ RNG()用于生成随机默认范围。image_noise = image + noise用于给图像添加噪声。- fig，axes = plot.subplots(nrows=1，ncols=3，figsize=(10，4)，sharex=True，sharey=True) 用于在屏幕上绘制图像。
- MSE _ none = mean _ squared _ error(image，image) 用于表示图像中的相似性。
- 轴[0]。imshow(image，cmap=plot.cm.gray，vmin=0，vmax=1) 用于在屏幕上显示轴。
- 轴[0]。set _ xlabel(f ' MSE:{ MSE _ none:. 2f }，SSIM: {ssim_none:.2f}') 用于给轴加 x 标签。
- 轴[0]。set_title('原始图像')用来给图像加标题。
import numpy as num
import matplotlib.pyplot as plot
from skimage import data, img_as_float
from skimage.metrics import structural_similarity as ssim
from skimage.metrics import mean_squared_error
image = img_as_float(data.camera())
rows, cols = image.shape
noise = num.ones_like(image) * 0.3 * (image.max() - image.min())
range = num.random.default_rng()
noise[range.random(size=noise.shape) > 0.6] *= -1
image_noise = image + noise
image_const = image + abs(noise)
fig, axes = plot.subplots(nrows=1, ncols=3, figsize=(10, 4),
sharex=True, sharey=True)
axis = axes.ravel()
mse_none = mean_squared_error(image, image)
ssim_none = ssim(image, image, data_range=image.max() - image.min())
mse_noise = mean_squared_error(image, image_noise)
ssim_noise = ssim(image, image_noise,
data_range=image_noise.max() - image_noise.min())
mse_const = mean_squared_error(image, image_const)
ssim_const = ssim(image, image_const,
data_range=image_const.max() - image_const.min())
axis[0].imshow(image, cmap=plot.cm.gray, vmin=0, vmax=1)
axis[0].set_xlabel(f'MSE: {mse_none:.2f}, SSIM: {ssim_none:.2f}')
axis[0].set_title('Original image')
axis[1].imshow(image_noise, cmap=plot.cm.gray, vmin=0, vmax=1)
axis[1].set_xlabel(f'MSE: {mse_noise:.2f}, SSIM: {ssim_noise:.2f}')
axis[1].set_title('Image with noise')
axis[2].imshow(img_const, cmap=plot.cm.gray, vmin=0, vmax=1)
axis[2].set_xlabel(f'MSE: {mse_const:.2f}, SSIM: {ssim_const:.2f}')
axis[2].set_title('Image plus constant')
plot.tight_layout()
plot.show()
输出:
运行上述代码后，我们得到以下输出。在输出中，我们可以看到屏幕上显示了 scikit 学习图像相似性。
scikit learn image similarity
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习图像聚类
在本节中，我们将了解 python 中的scikit learn image clustering works。
- 聚类被定义为将未标记的数据集分组或将数据分组到具有相似数据点的不同簇中。
- 这里我们使用谱聚类，它用于切割图形并最小化梯度的比率。
代码:
在下面的代码中，我们将从 sklearn.cluster 导入 spectral_clustering，通过它我们可以切割图形并最小化梯度的比率。
- x，y = NP . indexes((l，l)) 用于返回代表网格索引的数组。
imge = circle 1+circle 2+circle 3+circle 4用于创建四个圆。mask = imge.astype(bool)用于限制前景。- graph = image . img _ to _ graph(imge，mask=mask) 用于将图像转换为边缘带有渐变值的图形。
- label _ im = num . full(mask . shape，-1.0) 用于给出图形的完整形状。
- plot.matshow(imge)用于绘制图像。
- labels = spectral _ clustering(graph，n_clusters=2，eigen_solver="arpack") 用于最小化梯度的比率。
import numpy as num
import matplotlib.pyplot as plot
from sklearn.feature_extraction import image
from sklearn.cluster import spectral_clustering
l = 100
x, y = np.indices((l, l))
center1 = (29, 25)
center2 = (41, 51)
center3 = (68, 59)
center4 = (25, 71)
radius1, radius2, radius3, radius4 = 17, 15, 16, 15
circle1 = (x - center1[0]) ** 2 + (y - center1[1]) ** 2 < radius1 ** 2
circle2 = (x - center2[0]) ** 2 + (y - center2[1]) ** 2 < radius2 ** 2
circle3 = (x - center3[0]) ** 2 + (y - center3[1]) ** 2 < radius3 ** 2
circle4 = (x - center4[0]) ** 2 + (y - center4[1]) ** 2 < radius4 ** 2
imge = circle1 + circle2 + circle3 + circle4
mask = imge.astype(bool)
imge = imge.astype(float)
imge += 1 + 0.2 * num.random.randn(*imge.shape)
graph = image.img_to_graph(imge, mask=mask)
graph.data = num.exp(-graph.data / graph.data.std())
labels = spectral_clustering(graph, n_clusters=4, eigen_solver="arpack")
label_im = num.full(mask.shape, -1.0)
label_im[mask] = labels
plot.matshow(imge)
plot.matshow(label_im)
imge = circle1 + circle2
mask = imge.astype(bool)
imge = imge.astype(float)
imge += 1 + 0.2 * num.random.randn(*imge.shape)
graph = image.img_to_graph(imge, mask=mask)
graph.data = num.exp(-graph.data / graph.data.std())
labels = spectral_clustering(graph, n_clusters=2, eigen_solver="arpack")
label_im = num.full(mask.shape, -1.0)
label_im[mask] = labels
plot.matshow(imge)
plot.matshow(label_im)
plot.show()
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到屏幕上执行了 scikit learn 图像聚类。
scikit learn image clustering
另外，检查: Scikit 学习层次聚类
Scikit 学习图像增强
在本节中，我们将了解sci kit 如何在 python 中学习图像增强功能。
图像增强被定义为一种用于增加我们图像大小的技术，也是通过图像的变换来完成的。
代码:
在下面的代码中，我们将导入一些库，从中我们可以对图像进行放大。
- figure = plot . figure(tight _ layout = ' auto '，figsize=(10，7)) 用于在屏幕上绘制图形。
- imge = im read(' buter fly . jpg ')/255用于加载图像。
plot.imshow(img)用于绘制原始图像。
from skimage import transform
from skimage.transform import rotate, AffineTransform,warp
from skimage.util import random_noise
from skimage.filters import gaussian
from scipy import ndimage
import random
from skimage import img_as_ubyte
import os
**#basic Function to display image side by side**
def plotsides(imge1, imge2, title1, title2, cmap = None):
figure = plot.figure(tight_layout='auto', figsize=(10, 7))
figure.add_subplot(221)
plot.title(title1)
plot.imshow(imge)
figure.add_subplot(222)
plot.title(title2)
plot.imshow(imge2, cmap = None)
return fig
imge = imread('buterfly.jpg') / 255
plot.imshow(img)
plot.title('Original')
plot.show()
scikit learn augmentation original image
- rotate30 = rotate(imge，angle=30) 用于将图像旋转 30°的角度。
- rotate45 = rotate(imge，angle=45) 用于将图像旋转 45 度。
- rotate60 = rotate(imge，angle=60) 用于将图像旋转 60 度。
- rotate90 = rotate(imge，angle=90) 用于将图像旋转 90 度。
- figure = plot . figure(tight _ layout = ' auto '，figsize=(10，10)) 用于绘制屏幕上的所有图形。
- plot.title('旋转 30') 用于给屏幕加标题。
rotate30 = rotate(imge, angle=30)
rotate45 = rotate(imge, angle=45)
rotate60 = rotate(imge, angle=60)
rotate90 = rotate(imge, angle=90)
figure = plot.figure(tight_layout='auto', figsize=(10, 10))
figure.add_subplot(221)
plot.title('Rotate 30')
plot.imshow(rotate30)
figure.add_subplot(222)
plot.title('Rotate 45')
plot.imshow(rotate45)
figure.add_subplot(223)
plot.title('Rotate 60')
plot.imshow(rotate60)
figure.add_subplot(224)
plot.title('Rotate 90')
plot.imshow(rotate90)
plot.show()
scikit learn augmentation rotation images
- 这里， sheared = transform.warp(img，tf，order=1，preserve_range=True，mode='wrap') 用于将图像原物变换为 sheared。
tf = AffineTransform(shear=-0.5)
sheared = transform.warp(img, tf, order=1, preserve_range=True, mode='wrap')
sheared_figure = plot_side(img, sheared, 'Original', 'Sheared')
scikit learn augmentation sheared image
- 这里， warp_images = warp(imge，transform，mode="wrap") 就是对图像进行包裹。
- 这里， warp_figure = plot_side(imge，warp_images，' Original '，' Wrap images') 用于在屏幕上绘制图形。
transform = AffineTransform(translation=(-200,0))
warp_images = warp(imge,transform, mode="wrap")
warp_figure = plot_side(imge,warp_images , 'Original', 'Wrap images')
scikit learn image augmentation transformation
现在， noise_figure = plot_side(imge，Noise _ images，' Original '，' Noise_image') 用于创建和绘制噪声图像。
noisy_images = random_noise(imge, var=0.1**.01)
noise_figure = plot_side(imge,noisy_images , 'Original', 'Noise_image')
scikit learn augmentation noisy image
- blured _ images = ndimage . uniform _ filter(imge，size=(11，11，1)) 用于制作模糊图像。
- noise_figure = plot_side(imge，blured_images，'原始'，'模糊')用于在屏幕上绘制图像。
from scipy import ndimage
blured_images = ndimage.uniform_filter(imge, size=(11, 11, 1))
noise_figure = plot_side(imge,blured_images , 'Original', 'Blurred')
scikit learn image augmentation blurring
high brightness = imge+(100/255)用于增加图像的亮度。- figure _ highBrightness = plot _ side(imge，high brightness，' Original '，' brighted ')用于在屏幕上绘制图像。
highBrightness = imge + (100/255)
figure_highBrightness = plot_side(imge, highBrightness, 'Original', 'Brightened')
plot.show()
scikit learn image augmentation increasing brightness
up_down = np.flipud(imge)用于上下翻转图像。- figure _ Up Down = plot _ side(imge，up_down，' Original '，' Up-Down') 用于在屏幕上绘制图形。
# flip up-down using np.flipud
up_down = np.flipud(imge)
figure_updown = plot_side(imge, up_down, 'Original', 'Up-Down')
plot.show()
scikit learn image augmentation flipping up down
阅读: Scikit 学习分类教程
Scikit 学习图像数据集
在本节中，我们将了解Scikit 如何在 python 中学习图像数据集的工作方式。
图像数据集被定义为将图像的数据存储在数据容器中，并通过多种算法返回结果。
代码:
在下面的代码中，我们将从 sklearn.datasets 导入 load_sample_images，通过它我们可以在数据的帮助下加载图像。
len(datasets.images)用于获取图像的长度。first_imge_data.shape用于获取图像的形状。
from sklearn.datasets import load_sample_images
datasets = load_sample_images()
len(datasets.images)
first_imge_data = dataset.images[0]
first_imge_data.shape
scikit learn image dataset
first_imge_data.dtype 用于获取数据的类型。
first_imge_data.dtype
scikit learn image dataset type
阅读: Scikit 学习超参数调整
Scikit 学习图像预处理
在本节中，我们将了解 scikit 如何在 python 中学习图像预处理。
图像预处理定义为图像在用于模型训练之前进行合成的步骤。
代码:
在下面的代码中，我们将从 sklearn 导入 io 对图像进行预处理。
- 首先，files = OS . path . join(' ladybug . jpg ')用于加载图片。
- 第二， io.imshow(瓢虫)用于显示输入图像。
import os
import skimage
from skimage import io
files = os.path.join( 'ladybug.jpg')
ladybug = io.imread(files)
io.imshow(ladybug)
io.show()
输出:
运行上述代码后，我们得到以下输出。在输出中，我们可以看到 Scikit 学习图像预处理是在屏幕上完成的。
scikit learn image preprocessing
阅读: Scikit 学习 hidden _ layer _ size
Scikit 学习图像特征提取
在本节中，我们将学习scikit 如何学习 python 中的图像特征提取。
- 顾名思义，图像特征提取从图像中提取特征。特征提取与降维有关。
- 特征提取也被定义为减少能够轻松描述大量数据的资源数量。
代码:
在下面的代码中，我们将使用来自 skimage.io 的 imread.imshow 来运行图像。
在代码中，image1 = im read(' grasshopper . jpg ')用于加载图像。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from skimage.io import imread, imshow
image1 = imread('grasshopper.jpg')
imshow(image1);
scikit learn feature extraction original image
另外，image2 = imread(' grasshopper . jpg '，as_gray=True) 用于加载灰色阴影图像。
image2 = imread('grasshopper.jpg', as_gray=True)
imshow(image2);
scikit learn feature extraction greyscale image
print(image1.shape)用于打印 image1 的形状。- 打印(image2.shape) 用于打印 image2 的形状。
print(image1.shape)
print(image2.shape)
scikit learn image feature extraction shape
print(image1.size)用于打印 image1 的大小。print(image2.size)用于打印 image2 的大小。
print(image1.size)
print(image2.size)
scikit learn image feature extraction size
这里， feature2 = np.reshape(image2，(280 * 390 )) 用于查找对 image2 的形状进行整形并返回数组的特征。
feature2 = np.reshape(image2, (280 * 390 ))
feature2
scikit learn image feature extraction grayscale
而feature 1 = NP . shape(image1，(280 * 390 * 3)) 用于寻找对 image1 形状进行整形的特征并返回数组。
feature1 = np.reshape(image1, (280 * 390 * 3))
feature1
scikit learn image feature extraction original
阅读: Scikit 学习线性回归+例题
Scikit 学习图像分类
在本节中，我们将了解scikit 如何在 python 中学习图像分类的工作方式。
图像分类被定义为将图像分类到其不同类别的过程。
代码:
在下面的代码中，我们将导入一些可以对图像进行分类的库。
- clfdata['description'] = '已调整大小({0}x{1})的 rgb 动物图像'。格式(int(width)，int(height)) 用于给出数据的描述。
- current _ path = OS . path . join(src，subdir) 用于从路径中读取图像，并根据目标路径调整图像大小。
- clf data _ path = '/content/drive/my drive/Image '使用的是我的驱动器的路径。
import matplotlib.pyplot as plot
import numpy as num
import os
import pprint
pp = pprint.PrettyPrinter(indent=4)
import joblib
from skimage.io import imread
from skimage.transform import resize
def resize_all(src, pklname, include, width=150, height=None):
height = height if height is not None else width
clfdata = dict()
clfdata['description'] = 'resized ({0}x{1})animal images in rgb'.format(int(width), int(height))
clfdata['label'] = []
clfdata['filename'] = []
clfdata['data'] = []
pklname = f"{pklname}_{width}x{height}px.pkl"
for subdir in os.listdir(src):
if subdir in include:
print(subdir)
current_path = os.path.join(src, subdir)
for file in os.listdir(current_path):
if file[-3:] in {'jpg', 'png'}:
im = imread(os.path.join(current_path, file))
im = resize(im, (width, height))
clfdata['label'].append(subdir[:-4])
clfdata['filename'].append(file)
clfdata['data'].append(im)
joblib.dump(clfdata, pklname)
clfdata_path = '/content/drive/MyDrive/Image'
os.listdir(clfdata_path)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到动物数据集被打印在屏幕上。
scikit learn image classification dataset
- basename = 'animal_faces' 用作数据集的名称。
- resize_all(src=clfdata_path，pklname=basename，width=width，include=include) 用于调整数据集的大小。
basename = 'animal_faces'
width = 80
include = {'ChickenHead', 'BearHead', 'ElephantHead',
'EagleHead', 'DeerHead', 'MonkeyHead', 'PandaHead'}
resize_all(src=clfdata_path, pklname=basename, width=width, include=include)
scikit learn image classification resizes dataset
- clf data = joblib . load(f“{ basename } _ { width } x { width } px . pkl ')用于加载数据集。
- print('number of samples:'，len(clf data[' data '])用于打印样本数。
- print('keys:'，list(clfdata.keys()))用于打印键的数量。
- 打印('图像形状: '，clfdata['数据'][0]。【形状)】T1 用于打印图像的形状。
- print('labels:'，num . unique(clf data[' label '])用于打印标签。
- 计数器(clfdata['label']) 用于打印计数器。
from collections import Counter
clfdata = joblib.load(f'{basename}_{width}x{width}px.pkl')
print('number of samples: ', len(clfdata['data']))
print('keys: ', list(clfdata.keys()))
print('description: ', clfdata['description'])
print('image shape: ', clfdata['data'][0].shape)
print('labels:', num.unique(clfdata['label']))
Counter(clfdata['label'])
scikit learn image classification counter data
labels = num . unique(clf data[' label '])用于获取标签列表中所有唯一的值。- figure，axes = plot.subplots(1，len(labels)) 用于根据标签数量设置 matplotlib 图形和轴。
- idx = clfdata['label']。index(label) 用于获取与其搜索字符串相对应的第一个项目的索引。
labels = num.unique(clfdata['label'])
figure, axes = plot.subplots(1, len(labels))
figure.set_size_inches(17,6)
figure.tight_layout()
for axis, label in zip(axes, labels):
idx = clfdata['label'].index(label)
axis.imshow(clfdata['data'][idx])
axis.axis('off')
axis.set_title(label)
scikit learn image classification
- x_train，x_test，y_train，y_test=train_test_split(x，y，test_size=0.4，shuffle=True，random_state=44，)用于将数据集拆分为训练数据和测试数据。
- unique，counts = num.unique(y，return_counts=True) 用于计算每种类型的球场。
- counts = 100 * counts[sorted _ index]/len(y)用于表示百分比。
- counts = counts[sorted _ index]用于绘图作为计数。
- plot.xticks(xtemp，unique，rotation=45) 用于绘制 x 刻度。
- plot.suptitle('每种类型的相对照片数量')用于在屏幕上绘制字幕。
- plot_bar(y_train，loc='left') 用于在屏幕上绘制 y_train 条。
- plot_bar(y_test，loc='right') 用于在屏幕上绘制 y_test 条。
x = num.array(clfdata['data'])
y = num.array(clfdata['label'])
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(
x,
y,
test_size=0.4,
shuffle=True,
random_state=44,
)
def plot_bar(y, loc='left', relative=True):
width = 0.37
if loc == 'left':
n = -0.7
elif loc == 'right':
n = 0.7
unique, counts = num.unique(y, return_counts=True)
sorted_index = num.argsort(unique)
unique = unique[sorted_index]
if relative:
counts = 100*counts[sorted_index]/len(y)
ylabel_text = '% count'
else:
counts = counts[sorted_index]
ylabel_text = 'count'
xtemp = num.arange(len(unique))
plot.bar(xtemp + n*width, counts, align='center', alpha=.7, width=width)
plot.xticks(xtemp, unique, rotation=45)
plot.xlabel('equipment type')
plot.ylabel(ylabel_text)
plot.suptitle('relative amount of photos per type')
plot_bar(y_train, loc='left')
plot_bar(y_test, loc='right')
plot.legend([
'train ({0} photos)'.format(len(y_train)),
'test ({0} photos)'.format(len(y_test))
]);
scikit learn image classification graph
阅读: Scikit 学习功能选择
Scikit 学会图像分割
在本节中，我们将了解scikit 如何在 python 中学习图像分割的工作方式。
Scikit learn 图像分割被定义为平衡圆体积的算法。如果所有的圆大小相同，分割效果很好，如果大小不同，分割会失败。
代码:
- x，y = NP . indexes((l，l)) 用于返回代表网格索引的数组。
imge = circle 1+circle 2+circle 3+circle 4用于创建四个圆。mask = imge.astype(bool)用于限制前景。- graph = image . img _ to _ graph(imge，mask=mask) 用于将图像转换为边缘带有渐变值的图形。
- label _ im = num . full(mask . shape，-1.0) 用于给出图形的完整形状。
- plot.matshow(imge)用于绘制图像。
- labels = spectral _ clustering(graph，n_clusters=2，eigen_solver="arpack") 用于最小化梯度的比率。
import numpy as num
import matplotlib.pyplot as plot
from sklearn.feature_extraction import image
from sklearn.cluster import spectral_clustering
l = 100
x, y = num.indices((l, l))
center1 = (27, 23)
center2 = (39, 49)
center3 = (66, 57)
center4 = (23, 69)
radius1, radius2, radius3, radius4 = 15, 13, 14, 13
circle1 = (x - center1[0]) ** 2 + (y - center1[1]) ** 2 < radius1 ** 2
circle2 = (x - center2[0]) ** 2 + (y - center2[1]) ** 2 < radius2 ** 2
circle3 = (x - center3[0]) ** 2 + (y - center3[1]) ** 2 < radius3 ** 2
circle4 = (x - center4[0]) ** 2 + (y - center4[1]) ** 2 < radius4 ** 2
imge = circle1 + circle2 + circle3 + circle4
mask = imge.astype(bool)
imge = imge.astype(float)
imge += 2 + 0.3 * num.random.randn(*imge.shape)
graph = image.img_to_graph(imge, mask=mask)
graph.data = num.exp(-graph.data / graph.data.std())
labels = spectral_clustering(graph, n_clusters=4, eigen_solver="arpack")
label_im = num.full(mask.shape, -4.0)
label_im[mask] = labels
plot.matshow(imge)
plot.matshow(label_im)
imge = circle1 + circle2+circle3
mask = imge.astype(bool)
imge = imge.astype(float)
imge += 2 + 0.3 * num.random.randn(*imge.shape)
graph = image.img_to_graph(imge, mask=mask)
graph.data = num.exp(-graph.data / graph.data.std())
labels = spectral_clustering(graph, n_clusters=2, eigen_solver="arpack")
label_im = num.full(mask.shape, -2.0)
label_im[mask] = labels
plot.matshow(imge)
plot.matshow(label_im)
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到圆的大小和形状是相同的，分割不会失败。
scikit learn image segmentation
阅读: Scikit 学习岭回归
Scikit 学习图像识别
在本节中，我们将了解 Scikit 如何在 python 中学习图像识别的工作原理。
Scikit 学习图像识别是一个识别图像的过程，也用于识别物体。
代码:
在下面的代码中，我们将导入一些我们可以从中识别图像的库。
- dog = rescale(dog，1/3，mode='reflect') 用于将图像缩小到三分之一。
- dog_hog，dog_hog_img = hog(dog，pixels_per_cell=(14，14)，cells_per_block=(2，2)，orientations=9，visualize=True，block_norm='L2-Hys') 用于计算 hog 并返回可视化表示。
- a.tick_params(bottom=False，left=False，labelbottom=False，labelleft=False) 用于移除它们的刻度和标签。
- 轴[0]。set_title('dog') 用来给图像加标题。
from skimage.feature import hog
from skimage.io import imread
from skimage.transform import rescale
import matplotlib.pyplot as plot
dog = imread('dog.jpg', as_gray=True)
dog = rescale(dog, 1/3, mode='reflect')
dog_hog, dog_hog_img = hog(
dog, pixels_per_cell=(14,14),
cells_per_block=(2, 2),
orientations=9,
visualize=True,
block_norm='L2-Hys')
figure, axis = plot.subplots(1,2)
figure.set_size_inches(8,6)
[a.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)
for a in axis]
axis[0].imshow(dog, cmap='gray')
axis[0].set_title('dog')
axis[1].imshow(dog_hog_img, cmap='gray')
axis[1].set_title('hog')
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以识别一只狗的图像。
scikit learn image recognition
从这段代码中，我们可以看到在我们的模型中处理的一些数据点减少了。经过一些想象，我们可以认出这条狗。
print('number of pixels: ', dog.shape[0] * dog.shape[1])
print('number of hog features: ', dog_hog.shape[0])
scikit learn image recognition percentage
阅读: Scikit 学习决策树
Scikit 学习镜像安装
在这一节中，我们将了解到scikit 如何学习映像以在 python 中安装。
如果我们想安装 scikit 学习镜像，那么首先检查 sci kit-镜像是否已经安装，或者它是否工作，并检查安装版本。
我们可以通过以下命令检查 scikit-image 版本或其工作情况:
import skimage
print(skimage.__version__)
scikit learn install image check version
如果我们想要更新版本或再次安装，请使用以下命令:
pip install -U scikit-image
我们已经安装了 scikit-image 的更新版本，如图所示。
scikit learn install image update version
Read: Scikit-learn Vs Tensorflow
Scikit 学习图像读取图像
在本节中，我们将了解scikit 如何在 python 中学习图像读取图像工作。
Scikit 学习图像读取图像功能用于读取或处理图像。我们还可以在 scikit-image 模块的帮助下读取图像。
代码:
在下面的代码中，我们将导入一些库，从中我们可以读取图像并处理图像。
代码中，image _ gray = imread(' player . jpg '，as_gray=True) 用于读取灰度图像并加载到屏幕上。
from skimage.io import imread, imshow
import matplotlib.pyplot as plt
%matplotlib inline
image_gray = imread('player.jpg', as_gray=True)
imshow(image_gray)
scikit learn image read image
print(image_gray.shape)用于打印灰度图像的形状。
image_gray = imread('player.jpg', as_gray=True)
print(image_gray.shape)
print(image_gray)
scikit learn image read image gray shape
- image _ color = im read(' player . jpg '，as_gray=False) 用于加载和读取屏幕上的彩色图像。
print(image_color.shape)用于在屏幕上打印彩色图像形状。
from skimage.io import imread, imshow
import matplotlib.pyplot as plt
%matplotlib inline
image_color = imread('player.jpg', as_gray=False)
print(image_color.shape)
imshow(image_color)
scikit learn image read image color shape
另外，看看更多的 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit 学习映像,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习图像相似性
- Scikit 学习图像聚类
- Scikit 学习图像增强
- Scikit 学习图像数据集
- Scikit 学习图像预处理
- Scikit 学习图像特征提取
- sci kit-学习图像分类
- Scikit 学习图像分割
- Scikit 学习图像识别
- Scikit 学习映像安装
- Scikit 学习图像读取图像
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习 KNN 教程
在这个 Python 教程中，我们将学习 Scikit 学习 KNN 如何使用 Python 工作，我们还将涵盖与 Scikit 学习 KNN 相关的不同示例。我们将讨论这些话题。
- Scikit 学习 KNN
- Scikit 学习 KNN 分类
- Scikit 了解 KNN 的优点和缺点
- Scikit 学习 KNN 回归
- Scikit 学习 KNN 回归示例
- Scikit 学习 KNN 示例
- Scikit 学习 KNN 插补
- Scikit 学习 KNN 距离
目录
- Scikit 学习 KNN
- Scikit 学会 KNN 分类
- Scikit 了解 KNN 的优缺点
- Scikit 学习 KNN 回归
- Scikit 学习 KNN 回归的例子
- Scikit 学习 KNN 的例子
- Scikit 学会 KNN 插补
- Scikit 学习 KNN 距离
Scikit 学习 KNN
在这一节中，我们将了解如何 Scikit 学习 KNN 在 Python 中的工作。
- KNN 代表 K 近邻，它是机器学习的最简单和最容易的算法。
- KNN 是监督学习技术，用于分类和回归，但主要用于分类。
- KNN 算法在假设把新数据放在与新数据相似的类别中之后，假设可用数据和新数据之间的相似性。
- KNN 是一个懒惰学习算法的例子，因为它不从训练集学习，而是存储数据集，并在分类时执行其操作。
代码:
在下面的代码中，我们将从 sklearn.neighbors 导入 KNeighborsclssifier，它假设在假设将新数据放入与新类别相似且最接近的=at 类别后，可用数据和新数据之间存在相似性。
neighborsclassifier(n _ neighbors = 3)显示有 3 个最近邻居。- neighbor . fit(x，y) 用于拟合最近的邻居。
x = [[1], [2], [3], [4]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsClassifier
neighbour = KNeighborsClassifier(n_neighbors=3)
neighbour.fit(x, y)
scikit learn KNN
在下面的代码中，我们在一个表示数据集的数组的帮助下创建了最近邻类，并提出了一个问题，即哪个点离[2，2，2]最近。
samples = [[0., 0., 0.], [0., .6, 0.], [2., 1., .6]]
from sklearn.neighbors import NearestNeighbors
neighbour = NearestNeighbors(n_neighbors=1)
neighbour.fit(samples)
print(neighbour.kneighbors([[2., 2., 2.]]))
运行上面的代码后，我们得到下面的输出，我们可以看到它返回[1.72046]和[2]，这意味着元素在距离 1.72046 处。
scikit learn KNN Nearest neighbor
Read: Scikit-learn Vs Tensorflow
Scikit 学会 KNN 分类
在这一节中，我们将了解 Scikit 如何在 python 中学习 KNN 分类。
- Scikit 学习 KNN 是一种非参数分类方法。它用于分类和回归，但主要用于分类。
- 在 KNN 分类中，输出取决于类成员，并且对象通过其邻居的各种投票被分类，并且对象被分配到最接近 k 个最近邻居的那个类。
代码:
在下面的代码中，我们将从 sklearn 导入 neighbors 数据集，通过它我们可以将对象分配到与 k 个最近邻居最接近的那个类。
- X = iris.data[:，:2]用于取前两个特征。
- h = 0.04 用于取步长大小。
- colormap _ light = listed colormap([" yellow "，" orange "，" lightblue"])用于创建色彩映射表。
- 分类器=邻居。KNeighborsClassifier(n _ neighbors，weights=weights)用于创建邻居的实例。
- classifier.fit(X，y)用于拟合数据。
- xx，YY = num . mesh grid(num . arange(x _ min，x_max，h)，num.arange(y_min，y_max，h))用于绘制决策边界。
- plot.contourf(xx，yy，Z，colormap=colormap_light)用于将结果放入颜色图中。
import numpy as num
import matplotlib.pyplot as plot
import seaborn as sb
from matplotlib.colors import ListedColormap
from sklearn import neighbors, datasets
n_neighbors = 17
iris = datasets.load_iris()
X = iris.data[:, :2]
y = iris.target
h = 0.04
colormap_light = ListedColormap(["yellow", "orange", "lightblue"])
colormap_bold = ["pink", "c", "darkblue"]
for weights in ["uniform", "distance"]:
classifier = neighbors.KNeighborsClassifier(n_neighbors, weights=weights)
classifier.fit(X, y)
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = num.meshgrid(num.arange(x_min, x_max, h), num.arange(y_min, y_max, h))
Z = classifier.predict(num.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plot.figure(figsize=(8, 6))
plot.contourf(xx, yy, Z, colormap=colormap_light)
** # Plot the training points**
sb.scatterplot(
x=X[:, 0],
y=X[:, 1],
hue=iris.target_names[y],
palette=colormap_bold,
alpha=1.0,
edgecolor="brown",
)
plot.xlim(xx.min(), xx.max())
plot.ylim(yy.min(), yy.max())
plot.title(
"3-Class classification (k = %i, weights = '%s')" % (n_neighbors, weights)
)
plot.xlabel(iris.feature_names[0])
plot.ylabel(iris.feature_names[1])
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上完成了 scikit 学习 KNN 分类。
scikit learn KNN classification
阅读: Scikit 学习分类教程
Scikit 了解 KNN 的优缺点
在这一节中，我们将了解到 scikit 在 python 中学习 KNN 的优缺点。
优点:
- Scikit 学习 KNN 算法简单，易于实现。
- Scikit 学会 KNN 在做出任何预测之前没有训练的要求。
- 在 KNN sci kit learn 中，可以理想地添加新数据。
- Scikit learn 也称为懒惰学习者，因为它不需要任何实时预测培训。
- 懒惰的学习者使 KNN 比其他算法快得多。
- KNN 算法是非常强大的噪声训练数据。
缺点:
- 在 KNN 算法中，我们总是计算 K 的值，这有时可能很困难。
- 在 KNN，大型数据集的预测成本很高，因为计算新数据和令人兴奋的数据之间的距离的成本很高。
- KNN 对嘈杂的数据集非常敏感。
- 在 KNN，我们需要在将 KNN 算法应用于任何数据集之前进行要素缩放。
- KNN 不处理分类特征，因为很难找到分类变量的距离。
阅读: Scikit 学习超参数调整
Scikit 学习 KNN 回归
在本节中，我们将了解 scikit 如何在 Python 中学习 KNN 回归。
- Scikit 学习 KNN 回归算法被定义为回归的值是 K 个最近邻的值的平均值。
- 在 scikit learn KNN 中，程序的输出是对象的属性值。
代码:
在下面的代码中，我们将从 sklearn.neighbors 导入 KNeighborsRegressor，通过它回归的值是 K-nearest neighbors 值的平均值。
neighbors regressor(n _ neighbors = 4)用于寻找一个点的 K-邻居。- neighbor.fit(X，y) 用于拟合训练集的 k 近邻回归。
X = [[1], [2], [3], [4]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
neighbor = KNeighborsRegressor(n_neighbors=4)
neighbor.fit(X, y)
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上打印了 scikit learn knn 回归点。
scikit learn KNN regression
阅读: Scikit 学习线性回归
Scikit 学习 KNN 回归的例子
在这一节中，我们将讨论一个用 python 编写的 scikit 学习 KNN 回归的例子。
我们知道，scikit 学习的 KNN 回归 算法被定义为回归的值是 K 个最近邻居的值的平均值。
代码:
在下面的代码中，我们将从 sklearn 导入邻居，通过它我们可以获得回归的值。
- y[::5]+= 1 *(0.5–NP . rand . rand(8))用于给目标添加噪声。
n_neighbors = 7是拟合回归模型。- knn =邻居。KNeighborsRegressor(n _ neighbors，weights=weights) 用于寻找一个点的 k-邻居。
- y_ = knn.fit(x，y)。predict(T) 用于拟合训练集的 K- neighbors 回归。
- plot.plot(T，y_，color="blue "，label="prediction") 用于在屏幕上绘制图形。
- plot . title(" KNeighborsRegressor(k = % I，weights = '%s')" % (n_neighbors，weights)) 用于给图赋予标题。
import numpy as num
import matplotlib.pyplot as plot
from sklearn import neighbors
num.random.seed(0)
x = num.sort(5 * np.random.rand(40, 1), axis=0)
t = num.linspace(0, 5, 500)[:, num.newaxis]
y = num.sin(x).ravel()
y[::5] += 1 * (0.5 - np.random.rand(8))
n_neighbors = 7
for i, weights in enumerate(["uniform", "distance"]):
knn = neighbors.KNeighborsRegressor(n_neighbors, weights=weights)
y_ = knn.fit(x, y).predict(T)
plot.subplot(2, 1, i + 1)
plot.scatter(x, y, color="pink", label="data")
plot.plot(T, y_, color="blue", label="prediction")
plot.axis("tight")
plot.legend()
plot.title("KNeighborsRegressor (k = %i, weights = '%s')" % (n_neighbors, weights))
plot.tight_layout()
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制了 scikit 学习回归图。
scikit learn KNN regression example
阅读: Scikit 学习功能选择
Scikit 学习 KNN 的例子
在这一节中，我们将了解 scikit 如何在 python 中学习 KNN 示例。
- KNN 代表 K-最近邻是一种非参数分类算法。它用于分类和回归，但主要用于分类。
- KNN 算法在假设把新数据放在与新数据相似的类别中之后，假设可用数据和新数据之间的相似性。
代码:
在下面的输出中，我们将从 sklearn.neighbors 导入 KneihborsClassifier，通过它我们可以评估数据点成为一个组的成员的可能性。
iris = datasets . load _ iris()用于加载数据。- 分类器 1 =决策树分类器(max_depth=4) 用作训练分类器。
- xx，YY = num . mesh grid(num . arange(x _ min，x_max，0.1)，num.arange(y_min，y_max，0.1)) 用于绘制决策区域。
- Z = classifier . predict(num . c _[xx . ravel()，yy.ravel()]) 用于预测分类器。
- axarr[idx[0]，idx[1]]。scatter(X[:，0]，X[:，1]，c=y，s=20，edgecolor="r") 用于绘制图形上的点。
import numpy as num
import matplotlib.pyplot as plot
from sklearn import datasets
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier
iris = datasets.load_iris()
X = iris.data[:, [0, 2]]
y = iris.target
classifier1 = DecisionTreeClassifier(max_depth=4)
classifier2 = KNeighborsClassifier(n_neighbors=7)
classifier3 = SVC(gamma=0.1, kernel="rbf", probability=True)
eclassifier = VotingClassifier(
estimators=[("dt", classifier1), ("knn", classifier2), ("svc", classifier3)],
voting="soft",
weights=[2, 1, 2],
)
classifier1.fit(X, y)
classifier2.fit(X, y)
classifier3.fit(X, y)
eclassifier.fit(X, y)
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = num.meshgrid(num.arange(x_min, x_max, 0.1), num.arange(y_min, y_max, 0.1))
f, axarr = plot.subplots(2, 2, sharex="col", sharey="row", figsize=(10, 8))
for idx, classifier, tt in zip(
product([0, 1], [0, 1]),
[classifier1, classifier2, classifier3, eclassifier],
["Decision Tree (depth=4)", "KNN (k=7)", "Kernel SVM", "Soft Voting"],
):
Z = classifier.predict(num.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
axarr[idx[0], idx[1]].contourf(xx, yy, Z, alpha=0.4)
axarr[idx[0], idx[1]].scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor="r")
axarr[idx[0], idx[1]].set_title(tt)
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上显示了 scikit learn KNN 示例。
scikit learn KNN example
阅读: Scikit 学习岭回归
Scikit 学会 KNN 插补
在本节中，我们将了解 scikit 如何在 python 中学习 KNN 插补。
- KNN 是一种 K 近邻算法，用于识别与可用数据接近且相似的 K 个样本。
- 我们使用 k 个样本来猜测缺失数据点的值。通过 k 近邻的平均值，我们可以估算样本缺失值。
代码:
在下面的代码中，我们将从 sklearn.datasets 导入 load_diabetes，通过它我们可以用 imputer 替换这个数据集的缺失值。
n _ missing _ samples = int(n _ samples * missing _ rate)用于添加 75%行中的缺失值。- 从 sklearn.impute 导入 SimpleImputer，KNNImputer，iterative imputr用于从 sklearn.impute 模块导入估算器。
- full _ scores = cross _ val _ score(regressor，X_full，y_full，scoring = " neg _ mean _ squared _ error "，cv=N_SPLITS) 用于估计分数。
- imputr = simple imputr(missing _ values = NP . nan，add_indicator=True，strategy="constant "，fill_value=0) 用于替换缺失值 bu 零。
- imputr = KNNImputer(missing _ values = NP . nan，add _ indicator = True)KNN _ input _ scores = get _ scores _ for _ imputr(imputr，X_missing，y_missing) 用于根据所需的最近邻数来估算缺失值。
- imputr = simple imputr(missing _ values = NP . nan，strategy="mean "，add_indicator=True) 用于用均值对缺失值进行估算。
- plot.figure(figsize=(12，6)) 用于绘制图形。
- axis1.set_title("用糖尿病数据进行 KNN 插补")用于给图表加标题。
import numpy as num
from sklearn.datasets import load_diabetes
range = num.random.RandomState(42)
X_diabetes, y_diabetes = load_diabetes(return_X_y=True)
def add_missing_values(X_full, y_full):
n_samples, n_features = X_full.shape
missing_rate = 0.75
n_missing_samples = int(n_samples * missing_rate)
missing_samples = np.zeros(n_samples, dtype=bool)
missing_samples[:n_missing_samples] = True
range.shuffle(missing_samples)
missing_features = range.randint(0, n_features, n_missing_samples)
X_missing = X_full.copy()
X_missing[missing_samples, missing_features] = num.nan
y_missing = y_full.copy()
return X_missing, y_missing
X_miss_diabetes, y_miss_diabetes = add_missing_values(X_diabetes, y_diabetes)
range = num.random.RandomState(0)
from sklearn.ensemble import RandomForestRegressor
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import SimpleImputer, KNNImputer, IterativeImputer
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
N_SPLITS = 5
regressor = RandomForestRegressor(random_state=0)
def get_scores_for_imputer(imputer, X_missing, y_missing):
estimator = make_pipeline(imputer, regressor)
impute_scores = cross_val_score(
estimator, X_missing, y_missing, scoring="neg_mean_squared_error", cv=N_SPLITS
)
return impute_scores
x_labels = []
mses_diabetes = num.zeros(5)
stds_diabetes = num.zeros(5)
def get_full_score(X_full, y_full):
full_scores = cross_val_score(
regressor, X_full, y_full, scoring="neg_mean_squared_error", cv=N_SPLITS
)
return full_scores.mean(), full_scores.std()
mses_diabetes[0], stds_diabetes[0] = get_full_score(X_diabetes, y_diabetes)
x_labels.append("Full data")
def get_impute_zero_score(X_missing, y_missing):
imputer = SimpleImputer(
missing_values=np.nan, add_indicator=True, strategy="constant", fill_value=0
)
zero_impute_scores = get_scores_for_imputer(imputer, X_missing, y_missing)
return zero_impute_scores.mean(), zero_impute_scores.std()
mses_diabetes[1], stds_diabetes[1] = get_impute_zero_score(
X_miss_diabetes, y_miss_diabetes
)
x_labels.append("Zero imputation")
def get_impute_knn_score(X_missing, y_missing):
imputer = KNNImputer(missing_values=np.nan, add_indicator=True)
knn_impute_scores = get_scores_for_imputer(imputer, X_missing, y_missing)
return knn_impute_scores.mean(), knn_impute_scores.std()
mses_diabetes[2], stds_diabetes[2] = get_impute_knn_score(
X_miss_diabetes, y_miss_diabetes
)
x_labels.append("KNN Imputation")
def get_impute_mean(X_missing, y_missing):
imputer = SimpleImputer(missing_values=np.nan, strategy="mean", add_indicator=True)
mean_impute_scores = get_scores_for_imputer(imputer, X_missing, y_missing)
return mean_impute_scores.mean(), mean_impute_scores.std()
mses_diabetes[3], stds_diabetes[3] = get_impute_mean(X_miss_diabetes, y_miss_diabetes)
x_labels.append("Mean Imputation")
def get_impute_iterative(X_missing, y_missing):
imputer = IterativeImputer(
missing_values=np.nan,
add_indicator=True,
random_state=0,
n_nearest_features=5,
sample_posterior=True,
)
iterative_impute_scores = get_scores_for_imputer(imputer, X_missing, y_missing)
return iterative_impute_scores.mean(), iterative_impute_scores.std()
mses_diabetes[4], stds_diabetes[4] = get_impute_iterative(
X_miss_diabetes, y_miss_diabetes
)
x_labels.append("Iterative Imputation")
mses_diabetes = mses_diabetes * -1
import matplotlib.pyplot as plot
n_bars = len(mses_diabetes)
xval = num.arange(n_bars)
colors = ["b", "pink", "r", "orange", "green"]
plot.figure(figsize=(12, 6))
axis1 = plot.subplot(121)
for j in xval:
axis1.barh(
j,
mses_diabetes[j],
xerr=stds_diabetes[j],
color=colors[j],
alpha=0.6,
align="center",
)
axis1.set_title("KNN Imputation with Diabetes Data")
axis1.set_xlim(left=num.min(mses_diabetes) * 0.9, right=num.max(mses_diabetes) * 1.1)
axis1.set_yticks(xval)
axis1.set_xlabel("MSE")
axis1.invert_yaxis()
axis1.set_yticklabels(x_labels)
plot.show()
输出:
运行上述代码后，我们得到以下输出，可以看到屏幕上绘制了糖尿病数据的 KNN 插补。
scikit learn KNN imputation
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习 KNN 距离
在本节中，我们将了解 scikit 如何在 python 中学习 KNN 距离。
- Scikit 学习 KNN 距离定义为测量数据集最近邻的距离。
- KNN 算法在假设将新数据放入与新类别相似的类别后，假设可用数据与新数据之间的相似性。
代码:
在下面的代码中，我们将从 sklearn.neighbors 导入 NearestNeighbors，通过它我们可以测量离数据集最近的邻居的距离。
- 输入数据=数量。数组([[-2，2]，[-3，3]，[-4，4]，[1，2]，[2，3]，[3，4]，[4，5]]
)用于定义数据集。 nearest _ neighbor . fit(Input _ data)用于用输入数据集拟合模型。- distances，indexes = nearest _ neighbors . kneighbors(Input _ data)用于查找数据集的 K 个最近邻。
from sklearn.neighbors import NearestNeighbors
import numpy as num
Input_data = num.array([[-2, 2], [-3, 3], [-4, 4], [1, 2], [2, 3], [3, 4],[4, 5]])
nearest_neighbor = NearestNeighbors(n_neighbors = 4, algorithm='ball_tree')
nearest_neighbor.fit(Input_data)
distances, indices = nearest_neighbor.kneighbors(Input_data)
indices
distances
nearest_neighbor.kneighbors_graph(Input_data).toarray()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 scikit 学习 KNN 距离以数组的形式打印在屏幕上。
scikit learn KNN distance
您可能还想阅读 Scikit Learn 上的以下教程。
因此，在本教程中，我们讨论了 Scikit learn KNN 的工作方式，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习 KNN
- Scikit 学习 KNN 分类
- Scikit 了解 KNN 的优点和缺点
- Scikit 学习 KNN 回归
- Scikit 学习 KNN 回归示例
- Scikit 学习 KNN 示例
- Scikit 学习 KNN 插补
- Scikit 学习 KNN 距离
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习线性回归+示例
在这个 Python 教程中，我们将学习Scikit 如何在 Python 中学习线性回归工作，我们还将涵盖与线性回归相关的不同例子。我们将讨论这些话题。
- Scikit 学习线性回归
- Scikit 学习线性回归示例
- Scikit 了解线性回归的优缺点
- Scikit 学习线性回归梯度下降
- Scikit 学习线性回归 p 值
- Scikit 学习线性回归多重特性
- Scikit 学习线性回归分类变量
目录
- Scikit 学习线性回归
- Scikit 学习线性回归示例
- Scikit 学习线性回归的优缺点
- Scikit 学习线性回归梯度下降
- Scikit 学习线性回归 p 值
- Scikit 学习线性回归多重特性
- Scikit 学习线性回归分类变量
Scikit 学习线性回归
在这一节中，我们将了解如何 Scikit 学习线性回归在 Python 中的工作方式。
- 线性回归是预测建模技术的一种形式，它调查因变量和自变量之间的关系。
- 线性回归是建模因变量和自变量之间关系的线性方法。
代码:
在下面的代码中，我们将从 sklearn.linear_model 导入线性回归，通过它我们可以调查因变量和自变量之间的关系。
回归=线性回归()。fit(x，y)用于拟合线性模型。
import numpy as np
from sklearn.linear_model import LinearRegression
x = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
# y = 1 * x_0 + 2 * x_1 + 3
y = np.dot(x, np.array([1, 2])) + 3
regression = LinearRegression().fit(x, y)
regression.score(x, y)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到线性回归的分数打印在屏幕上。
scikit learn linear regression
另外，检查: Scikit-learn 逻辑回归
Scikit 学习线性回归示例
在本节中，我们将了解如何 scikit 学习 Python 中的线性回归示例工作。
正如我们所知，线性回归评估一个或多个预测变量之间的关系。
代码:
在下面的代码中，我们将从 sklearn 导入数据集 linear_model，通过它我们可以评估预测变量之间的关系。
- diabetes_x，diabetes _ y = datasets . load _ diabetes(return _ X _ y = True)用于导入糖尿病数据集。
- diabetes_x = diabetes_x[:，np.newaxis，2] 仅使用一个特征。
- diabetes _ x _ train = diabetes _ x[:-20]用于将数据拆分成训练集或测试集。
- 回归=线性 _ 模型。linear regression()用于创建一个线性回归对象。
- regression . fit(diabetes _ x _ train，diabetes_y_train) 用于使用训练集对模型进行训练。
- 打印(" Coefficients: \n "，regression.coef_) 用于打印系数。
- print(" meansquadererror:% . 2f " % mean _ squared _ error(diabetes _ y _ test，diabetes_y_pred)) 用于计算均方误差。
- plot . scatter(diabetes _ x _ test，diabetes_y_test，color="blue") 用于绘制散点图。
import matplotlib.pyplot as plot
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score
diabetes_x, diabetes_y = datasets.load_diabetes(return_X_y=True)
diabetes_x = diabetes_x[:, np.newaxis, 2]
diabetes_x_train = diabetes_x[:-20]
diabetes_x_test = diabetes_x[-20:]
diabetes_y_train = diabetes_y[:-20]
diabetes_y_test = diabetes_y[-20:]
regression = linear_model.LinearRegression()
regression.fit(diabetes_x_train, diabetes_y_train)
diabetes_y_pred = regression.predict(diabetes_x_test)
print("Coefficients: \n", regression.coef_)
print("Mean squared error: %.2f" % mean_squared_error(diabetes_y_test, diabetes_y_pred))
print("Coefficient of determination: %.2f" % r2_score(diabetes_y_test, diabetes_y_pred))
plot.scatter(diabetes_x_test, diabetes_y_test, color="blue")
plot.plot(diabetes_x_test, diabetes_y_pred, color="red", linewidth=3)
plot.xticks(())
plot.yticks(())
plot.show()
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到均方误差和决定系数打印在屏幕上。
scikit learn linear regression example
阅读: Scikit 学习决策树
Scikit 学习线性回归的优缺点
在这一节中，我们将了解到 Scikit 学习线性回归的优点和T2 在 Python 中的缺点。
优点:
- 线性回归简单且易于实施，并且解释了输出的系数。
2.线性回归避免了降维技术，但允许过度拟合。
3.当我们研究因变量和自变量之间的关系时，线性回归是最合适的。
4.与其他算法相比，线性回归的复杂性较低。
缺点:
- 在线性回归中，存在对边界和回归有很大影响的异常值。
2.线性回归关注因变量和自变量的平均值。如果平均值给出了单个变量的完整描述，那么线性变量不能给出变量之间关系的描述。
3.线性回归研究因变量和自变量之间的关系，因此这意味着它们之间存在直线关系。
阅读:Scikit-learn Vs tensor flow–详细对比
Scikit 学习线性回归梯度下降
在本节中，我们将了解到scikit 如何在 Python 中学习线性回归梯度下降 工作。
- 在前进之前，我们应该有一些关于梯度下降的知识。梯度作为斜率函数工作，并且梯度简单地计算权重的变化。
- 梯度越高，斜率越低，模型越快。
代码:
在下面的代码中，我们将从 sklearn.linear_model 导入 SGDClassifier，通过它我们可以作为斜率函数工作。
from sklearn.linear_model import SGDClassifier
x = [[0., 0.], [1., 1.]]
y = [0, 1]
clf = SGDClassifier(loss="hinge", penalty="l2", max_iter=5)
clf.fit(x, y)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到随机梯度下降值打印在屏幕上。
scikit learn linear regression gradient descent
Scikit 学习线性回归 p 值
在本节中，我们将了解sci kit 如何在 python 中学习线性回归 p 值的工作方式。
p 值被定义为当零假设为零时的概率，或者我们可以说，告诉零假设的统计显著性被拒绝或不被拒绝。一般来说，p 值小于 0.05
代码:
在下面的代码中，我们将从 sklearn.linear_model 导入 LinearRegression，通过它我们计算 p 值。
sm.add_constant(x)用于添加常量。p.fit()用于拟合数值。
import pandas as pd
import numpy as np
from sklearn import datasets, linear_model
from sklearn.linear_model import LinearRegression
import statsmodels.api as sm
from scipy import stats
diabetesdataset = datasets.load_diabetes()
x = diabetesdataset.data
y = diabetesdataset.target
x2 = sm.add_constant(x)
p = sm.OLS(y, x2)
p2 = p.fit()
print(p2.summary())
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 p 值被打印在屏幕上。
scikit learn linear regression p-value
阅读: Scikit 学习层次聚类
Scikit 学习线性回归多重特性
在本节中，我们将了解Python 中的线性回归多重特性如何工作。
- 众所周知，线性回归是预测建模技术的一种形式，它调查因变量和自变量之间的关系。
- 线性回归有多个特征，其中一个特征是普通最小二乘法。
- 这种线性回归用它们的系数来拟合线性模型，以最小化数据集中被观察目标之间的剩余观察总和。
代码:
在下面的代码中，我们将从 sklearn 导入 linear_model，通过它我们计算回归系数。
- regression.fit([[0，0]，[1，1]，[2，2]，[0，1，2]) 用于拟合模型。
regression.coef_用于计算模型的系数。
from sklearn import linear_model
regression = linear_model.LinearRegression()
regression.fit([[0, 0], [1, 1], [2, 2]], [0, 1, 2])
regression.coef_
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到回归系数被打印在屏幕上。
scikit learn linear regression multiple features
另外，请阅读: Scikit 学习功能选择
Scikit 学习线性回归分类变量
在本节中，我们将学习 scikit 如何在 Python 中学习线性回归分类变量工作。
在继续之前，我们将有一些关于分类变量的知识。
分类变量被定义为只接受非数字值的变量，如年龄、性别等。
代码:
在下面的代码中，我们将从 sklearn 导入线性回归，通过它我们可以创建一个分类虚拟变量。
数据= pd。DataFrame({'color': ['orange '，' blue '，' pink '，' yellow']}) 用于创建数据集。
from sklearn import linear_model
import pandas as pd
data = pd.DataFrame({'color': ['orange', 'blue', 'pink', 'yellow']})
print(pd.get_dummies(data))
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到分类数据被打印在屏幕上。
scikit learn linear regression categorical variable
另外，看看 Scikit learn 上的更多教程。
因此，在本教程中，我们讨论了Scikit learn linear regression，并涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习线性回归
- Scikit 学习线性回归示例
- Scikit 了解线性回归的优缺点
- Scikit 学习线性回归梯度下降
- Scikit 学习线性回归 p 值
- Scikit 学习线性回归多重特性
- Scikit 学习线性回归分类变量
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
sci kit-学习逻辑回归
原文：https://pythonguides.com/scikit-learn-logistic-regression/
在这个 Python 教程中，我们将学习sci kit-learn logistic regression，我们还将涵盖与sci kit-learn logistic regression相关的不同示例。我们将讨论这些话题。
- sci kit-学习逻辑回归
- sci kit-学习逻辑回归标准误差
- sci kit-学习逻辑回归系数
- sci kit-学习逻辑回归 p 值
- sci kit-了解逻辑回归特性的重要性
- sci kit-学习逻辑回归分类变量
- Scikit-learn 逻辑回归交叉验证
- sci kit-学习逻辑回归阈值
目录
- Scikit-learn 逻辑回归
- sci kit-学习逻辑回归标准误差
- sci kit-学习逻辑回归系数
- sci kit-学习逻辑回归 p 值
- sci kit-学习逻辑回归特征重要性
- sci kit-学习逻辑回归分类变量
- Scikit-learn 逻辑回归交叉验证
- sci kit-学习逻辑回归阈值
Scikit-learn 逻辑回归
在本节中，我们将在 scikit-learn 中了解如何使用逻辑回归。
- 逻辑回归是一种防止二元分类的统计方法，或者我们可以说，当因变量为二元时进行逻辑回归。
- 二分意味着有两个可能的类，如二进制类(0&1)。
- 逻辑回归用于分类和回归。它计算事件发生的概率。
代码:
在这段代码中，我们将借助 sklearn 库导入 load_digits 数据集。数据内置在 sklearn 中，我们不需要上传数据。
from sklearn.datasets import load_digits
digits = load_digits()
我们已经可以在 sklearn 的帮助下导入数据。从下面的命令上传的数据中，我们可以看到数据集中有 1797 个图像和 1797 个标签。
print('Image Data Shape' , digits.data.shape)
print("Label Data Shape", digits.target.shape
在下面的输出中，我们可以看到图像数据形状值和标签数据形状值正在屏幕上打印。
Importing dataset value
在这一部分，我们将看到我们的图像和标签看起来如何像图像，并帮助唤起您的数据。
- plot.figure(figsize=(30，4)) 用于在屏幕上绘制图形。
- for index，(image，label)in enumerate(zip(digits . data[5:10]，digits . target[5:10]):用于给图片赋予完美的大小或标签。
- plot.subplot(1，5，index + 1)用于绘制索引。
- plot . im show(NP . shape(image，(8，8))，cmap=plt.cm.gray) 用于对图像进行整形。
- plot.title('Set: %i\n' % label，fontsize = 30) 用于给图像加标题。
import numpy as np
import matplotlib.pyplot as plot
plot.figure(figsize=(30,4))
for index, (image, label) in enumerate(zip(digits.data[5:10], digits.target[5:10])):
plot.subplot(1, 5, index + 1)
plot.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plot.title('Set: %i\n' % label, fontsize = 30)
运行上面的代码后，我们得到下面的输出，我们可以看到图像以 Set5，Set6，Set7，Set8，Set9 的形式绘制在屏幕上。
Enumerate digits target set
在下面的代码中，我们将数据分为两种形式:训练数据和测试数据。
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)
这里我们从 sklearn 导入逻辑回归。sklearn 用于专注于数据集建模。
from sklearn.linear_model import LogisticRegression
在下面的代码中，我们创建了模型的一个实例。在这里，所有未指定的参数都设置为默认值。
logisticRegression= LogisticRegression()
上面我们把数据分成两组训练和测试数据。我们可以在训练完我们想要测试的数据后训练模型
logisticRegression.fit(x_train, y_train)
该模型可以在模型训练过程中学习，并从一个观察预测数据，并以数组的形式返回数据。
logisticRegression.predict(x_test[0].reshape(1,-1)
在下面的输出中，我们看到 NumPy 数组在预测一次观察后返回。
Return the array
从下面的代码中，我们可以一次预测多个观察值。
logisticRegression.predict(x_test[0:10])
从这段代码中，我们可以预测整个数据。
logisticRegression.predict(x_test[0:10])
经过训练和测试，我们的模型是准备好了还是没有发现，我们可以衡量模型的准确性，我们可以使用评分方法来获得模型的准确性。
predictions = logisticRegression.predict(x_test)
score = logisticRegression.score(x_test, y_test)
print(score)
在这个输出中，我们可以通过使用评分方法来获得模型的准确性。
Predict the accuracy of a model
另外，检查: Scikit 学习决策树
sci kit-学习逻辑回归标准误差
正如我们所知，逻辑回归是一种防止二元分类的统计方法，并且我们知道当因变量为二元时进行逻辑回归。
这里我们可以研究逻辑标准误差。标准误差被定义为模型的系数是协方差矩阵的对角元素的平方根。
代码:
在下面的代码中，我们将处理逻辑回归的标准误差，因为我们知道标准误差是协方差矩阵对角元素的平方根。
from sklearn.metrics import mean_squared_error
y_true = [4, -0.6, 3, 8]
y_pred = [3.5, 0.1, 3, 9]
mean_squared_error(y_true, y_pred)
0.475
y_true = [4, -0.6, 3, 8]
y_pred = [3.5, 0.1, 3, 9]
mean_squared_error(y_true, y_pred, squared=False)
0.712
y_true = [[0.6, 2],[-2, 2],[8, -7]]
y_pred = [[1, 3],[-1, 3],[7, -6]]
mean_squared_error(y_true, y_pred)
0.808
mean_squared_error(y_true, y_pred, squared=False)
0.922
mean_squared_error(y_true, y_pred, multioutput='raw_values')
array=([0.51666667, 2])
mean_squared_error(y_true, y_pred, multioutput=[0.3, 0.7])
0.925
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到错误值已经生成并显示在屏幕上。
Scikit-learn logistic regression standard error
阅读: Scikit 学习随机森林
sci kit-学习逻辑回归系数
在本节中，我们将了解如何在 scikit-learn 中使用逻辑回归系数。
系数被定义为给定项的值彼此相乘的数。这里，逻辑回归表示变量的大小和方向。
代码:
在下面的代码中，我们将库作为 pd 导入熊猫，作为 np 导入 numpy，作为 sl 导入 sklearn。
- panda 库用于数据操作，
numpy用于处理数组。 - sklearn 库用于专注于建模数据，而不是专注于操纵数据。
- x = np.random.randint(0，7，size=n) 用于生成随机函数。
- res_sd = sd。Logit(y，x)。fit(method="ncg "，maxiter=max_iter) 用于执行不同的静态任务。
print(res_sl.coef_)用于在屏幕上打印系数。
import pandas as pd
import numpy as np
import sklearn as sl
from sklearn.linear_model import LogisticRegression
import statsmodels.api as sd
n = 250
x = np.random.randint(0, 7, size=n)
y = (x > (0.10 + np.random.normal(0, 0.10, n))).astype(int)
display(pd.crosstab( y, x ))
max_iter = 150
res_sd = sd.Logit(y, x).fit(method="ncg", maxiter=max_iter)
print(res_sd.params)
res_sl = LogisticRegression( solver='newton-cg', multi_class='multinomial', max_iter=max_iter, fit_intercept=True, C=1e8 )
res_sl.fit( x.reshape(n, 1), y )
print(res_sl.coef_)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上打印了 scikit learn 逻辑回归系数。
scikit learn logistic regression coefficient
阅读: Scikit 学习功能选择
sci kit-学习逻辑回归 p 值
在本节中，我们将了解如何在 scikit learn 中计算逻辑回归的 p 值。
逻辑回归 pvalue 用于检验零假设，其系数等于零。最低的 p 值是 < 0.05 ，这个最低的值表示你可以拒绝零假设。
代码:
在下面的代码中，我们将把库 import numpy 作为处理数组的 np 来导入。
- 在此，我们首先计算 scikit 学习逻辑回归的 z 分数。
- def logit_p1value(model，x): 在这里，我们使用一些类似 model 和 x 的参数。
- 模型:用于拟合的 sklearn.linear_model。具有截距和大 C 值的逻辑回归
- x: 用作模型拟合的矩阵。
- model = logistic regression(C = 1e 30)。fit(x，y) 用于测试 pvalue。
- print(logit_pvalue(model，x)) 进一步测试该值后，通过该方法将该值打印在屏幕上。
- sd_model = sd。Logit(y，sm.add_constant(x))。fit(disp=0) 用于比较 pvalue 和 statmodels。
import numpy as np
from scipy.stats import norm
from sklearn.linear_model import LogisticRegression
def logit_p1value(model, x):
p1 = model.predict_proba(x)
n1 = len(p1)
m1 = len(model.coef_[0]) + 1
coefs = np.concatenate([model.intercept_, model.coef_[0]])
x_full = np.matrix(np.insert(np.array(x), 0, 1, axis = 1))
answ = np.zeros((m1, m1))
for i in range(n1):
answ = answ + np.dot(np.transpose(x_full[i, :]), x_full[i, :]) * p1[i,1] * p1[i, 0]
vcov = np.linalg.inv(np.matrix(answ))
se = np.sqrt(np.diag(vcov))
t1 = coefs/se
p1 = (1 - norm.cdf(abs(t1))) * 2
return p1
x = np.arange(10)[:, np.newaxis]
y = np.array([0,0,0,1,0,0,1,1,1,1])
model = LogisticRegression(C=1e30).fit(x, y)
print(logit_pvalue(model, x))
import statsmodels.api as sd
sd_model = sd.Logit(y, sm.add_constant(x)).fit(disp=0)
print(sd_model.pvalues)
sd_model.summary()
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到屏幕上创建了逻辑回归 p 值。
scikit learn logistic regression p value
sci kit-学习逻辑回归特征重要性
在本节中，我们将了解到在 scikit learn 中逻辑回归的重要性。
特征重要性被定义为一种为输入特征分配值的方法，这些值是根据它们对预测目标变量的帮助程度来分配的。
代码:
在下面的代码中，我们将从 sklearn.linear_model 导入 LogisticRegression，还将导入 pyplot 以在屏幕上绘制图形。
- x，y = make _ classification(n _ samples = 100，n_features=10，n _ informative = 5，n_redundant=5，random_state=1) 用于定义 dtatset。
model = LogisticRegression()用于定义模型。- model.fit(x，y) 用于拟合模型。
- impact = model . coef _[0]用于获取特征的重要性。
- py plot . bar([X for X in range(len(impact))]，impact)用于绘制特征重要性。
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from matplotlib import pyplot
x, y = make_classification(n_samples=100, n_features=10, n_informative=5, n_redundant=5, random_state=1)
model = LogisticRegression()
model.fit(x, y)
imptance = model.coef_[0]
for i,j in enumerate(importance):
print('Feature: %0d, Score: %.5f' % (i,j))
pyplot.bar([X for X in range(len(imptance))], imptance)
pyplot.show()
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到屏幕上显示了逻辑回归特征的重要性。
scikit learn logistic regression feature importance
另外，请阅读: Scikit-learn 与 tensor flow–详细对比
sci kit-学习逻辑回归分类变量
在本节中，我们将了解 scikit learn 中的逻辑回归分类变量。
顾名思义，将数据分为不同的类别，或者我们可以说分类变量是一个单独分配给某个基本定性属性的特定组的变量。
代码:
在下面的代码中，我们将导入一些库如 import pandas as pd ， import NumPy as np 也导入 copy。Pandas 用于操作和分析数据，NumPy 用于支持多个数组。
import pandas as pd
import numpy as np
import copy
%matplotlib inline
在这里，我们可以上传 CSV 数据文件，以获取客户的一些数据。
df_data.head() 用于显示文件内数据的前五行。
df_data = pd.read_csv('data.csv')
df_data.head()
在下面的输出中，我们可以看到，我们从屏幕上显示的数据集中获得了前五行。
scikit learn logistic regression categorical variable data
print(df_data.info()) 用于打印屏幕上的数据信息。
print(df_data.info())
Printing the data info
生成箱线图是为了显示数据集的完整摘要。
df_data.boxplot('dep_time','origin',rot = 30,figsize=(5,6))
Boxplot
给你。如果在数据框中进行了任何更改，并且此更改不影响原始数据，则使用 copy()方法。
cat_df_data = df_data.select_dtypes(include=['object']).copy()
。hed()函数用于检查你是否有任何需要填充的内容
cat_df_data.head()
Filter the columns
这里我们使用这些命令来检查数据集中的空值。由此，我们可以得到缺失值的总数。
print(cat_df_data.isnull().values.sum())
Missing values
这将检查空值的列分布。
print(cat_df_data.isnull().sum())
column-wise distribution
。value_count()方法用于返回每个类别的频率分布。
cat_df_data = cat_df_data.fillna(cat_df_data['tailnum'].value_counts().index[0])
现在，我们可以在分配不同的方法后再次检查空值，结果是零计数。
print(cat_df_data.isnull().values.sum())
Result of null value
。value_count() 方法用于分类特征的类别的频率分布。
print(cat_df_data['carrier'].value_counts())
Frequency distribution
这用于计算特征的不同类别。
print(cat_df_data['carrier'].value_counts().count())
Feature of different category
- SNS . bar plot(carrier _ count . index，carrier_count.values，alpha=0.9) 用于绘制条形图。
- PLT . title(‘载波频率分布’)用于给柱状图命名。
- plt.ylabel('出现次数'，fontsize =12)用于给 y 轴加标签。
- plt.xlabel('Carrier '，fontsize=12) 用于给 x 轴加标签。
import seaborn as sns
import matplotlib.pyplot as plt
carrier_count = cat_df_data['carrier'].value_counts()
sns.set(style="darkgrid")
sns.barplot(carrier_count.index, carrier_count.values, alpha=0.9)
plt.title('Frequency Distribution of Carriers')
plt.ylabel('Number of Occurrences', fontsize=12)
plt.xlabel('Carrier', fontsize=12)
plt.show()
在这张图片中，我们可以看到条形图绘制在屏幕上。
Bar graph of a categorical variable
- labels = cat _ df _ data[' carrier ']。astype(' category '). cat . categories . to list()用于给图表加标签。
- size =[counts[var _ cat]for var _ cat in labels]用于给出饼图的大小。
- fig1，ax1 = plt.subplots() 用于绘制图表。
labels = cat_df_data['carrier'].astype('category').cat.categories.tolist()
counts = cat_df_data['carrier'].value_counts()
sizes = [counts[var_cat] for var_cat in labels]
fig1, ax1 = plt.subplots()
ax1.pie(sizes, labels=labels, autopct='%1.1f%%', shadow=True) #autopct is show the % on plot
ax1.axis('equal')
plt.show()
在下面的输出中，我们可以看到屏幕上绘制了一个饼图，其中的值被分成不同的类别。
Plotting the pie chart
阅读: Scikit 学习情绪分析
Scikit-learn 逻辑回归交叉验证
在本节中，我们将了解 scikit learn 中的逻辑回归交叉验证。
- 正如我们所知，scikit 学习库用于集中建模数据。它只是专注于数据建模，而不是加载数据。
- 这里使用 scikit learn 我们还创建了逻辑回归交叉验证的结果。
- 交叉验证是一种在不同迭代中使用测试序列和测试模型的不同数据位置的方法。
代码:
在下面的代码中，我们导入不同的库来获得逻辑回归交叉验证的准确值。
- x，y = make _ classification(n _ samples = 1000，n_features=20，n _ informative = 15，n_redundant=5，random_state=1) 用于创建数据集。
- CV = KFold(n_splits=10，random_state=1，shuffle=True) 用于准备交叉验证程序。
model = LogisticRegression()用于创建模型。- score = cross_val_score(model，x，y，scoring='accuracy '，cv=CV，n_jobs=-1) 用于评估模型。
- print(' Accuracy:% . 3f(% . 3f)' %(mean(score)，std(score))) 用于准备绩效报告。
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
x, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
CV = KFold(n_splits=10, random_state=1, shuffle=True)
model = LogisticRegression()
score = cross_val_score(model, x, y, scoring='accuracy', cv=CV, n_jobs=-1)
print('Accuracy: %.3f (%.3f)' % (mean(score), std(score)))
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到交叉验证的准确性显示在屏幕上。
scikit learn logistic regression cross-validation
sci kit-学习逻辑回归阈值
在本节中，我们将了解如何在 scikit learn 中获取逻辑回归阈值。
- 众所周知，逻辑回归是一种防止二元分类的统计方法。二进制类被定义为 0 或 1，或者我们可以说是真或假。
- 在这里，逻辑回归将每一行指定为真的概率，并且如果该值小于 0.5，则将该值作为 0 进行预测。
- 阈值的默认值为 0.5。
代码:
在下面的代码中，我们将导入不同的方法，从中我们得到逻辑回归的阈值。阈值的默认值为 0.5，如果阈值小于 0.5，则我们将该值视为 0。
- X，y = make _ classification(n _ samples = 1000，n_features=2，n_redundant=0，n_clusters_per_class=1，weights=[0.99]，flip_y=0，random_state=4) 用于生成数据集。
- trainX，testX，trainy，testy = train_test_split(X，y，test_size=0.5，random_state=2，strategy = y)用于将数据拆分为训练和测试。
- models.fit(trainX，trainy) 用于拟合模型。
yhat = model . predict _ proba(testX)用于预测概率。- yhat = yhat[:，1] 仅用于保持正面结果的概率。
- fpr，tpr，thresholds = roc_curve(testy，yhat) 用于计算 roc 曲线。
from numpy import argmax
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve
X, y = make_classification(n_samples=1000, n_features=2, n_redundant=0,
n_clusters_per_class=1, weights=[0.99], flip_y=0, random_state=4)
trainX, testX, trainy, testy = train_test_split(X, y, test_size=0.5, random_state=2, stratify=y)
models = LogisticRegression(solver='lbfgs')
models.fit(trainX, trainy)
yhat = model.predict_proba(testX)
yhat = yhat[:, 1]
fpr, tpr, thresholds = roc_curve(testy, yhat)
Jt = tpr - fpr
ix = argmax(Jt)
best_threshold = thresholds[ix]
print('Best Threshold=%f' % (best_threshold))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到阈值被打印在屏幕上。
scikit learn logistic regression threshold
因此，在本教程中，我们讨论了sci kit learn logistic regression，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- sci kit-学习逻辑回归
- sci kit-学习逻辑回归标准误差
- sci kit-学习逻辑回归系数
- sci kit-学习逻辑回归 p 值
- sci kit-了解逻辑回归特性的重要性
- sci kit-学习逻辑回归分类变量
- Scikit-learn 逻辑回归交叉验证
- sci kit-学习逻辑回归阈值
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 非线性学习[完整指南]
在这个 Python 教程中，我们将学习Scikit 如何学习非线性工作，我们还将涵盖与 Scikit 学习非线性相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习非线性
- Scikit 学习非线性回归
- Scikit 学习非线性回归示例
- Scikit 学习非线性 SVM
- Scikit 学习非线性模型
- Scikit 学习非线性分类器
- Scikit 学习非线性降维
- Scikit 学习非线性 PCA
在继续本教程之前，我们建议您阅读一下什么是 Python 中的 Scikit Learn。
目录
- Scikit 学习非线性
- Scikit 学习非线性回归
- Scikit 学习非线性回归示例
- Scikit 学习非线性 SVM
- Scikit 学习非线性模型
- Scikit 学习非线性分类器
- Scikit 学习非线性降维
- Scikit 学习非线性 PCA
Scikit 学习非线性
在本节中，我们将学习 Scikit 如何学习 python 中的非线性作品。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建 scikit 学习非线性。
- x = num . sort(5 * num . random . rand(42，1)，axis=0) 用于生成相同的数据。
- y[::5]+= 3 *(0.5–num . rand . rand(9))用于向目标添加噪声。
- svrrbf = SVR(kernel="rbf "，C=100，gamma=0.1，epsilon=0.1) 用于它的回归模型。
lw = 2用来看结果。- fig，axes = plot.subplots(nrows=1，ncols=3，figsize=(15，10)，sharey=True) 用于在屏幕上绘制图形和轴。
- 轴【ix】。plot(x，svr.fit(x，y)。predict(x)，color=model_color[ix]，lw=lw，label{}model”。format(kernel_label[ix])，)用于在屏幕上绘制轴。
- 轴【ix】。scatter(x[svr.support_]，y[svr.support_]，facecolor="none "，edgecolor=model_color[ix]，s=50，label="{} support vectors "。format(kernel_label[ix])，)用于在屏幕上绘制散点图。
- fig.text(0.5，0.04，" data "，ha="center "，va="center") 用于文字到图形。
import numpy as num
from sklearn.svm import SVR
import matplotlib.pyplot as plot
x = num.sort(5 * num.random.rand(42, 1), axis=0)
y = num.sin(x).ravel()
y[::5] += 3 * (0.5 - num.random.rand(9))
svrrbf = SVR(kernel="rbf", C=100, gamma=0.1, epsilon=0.1)
lw = 2
svrs = [svrrbf]
kernel_label = ["RBF"]
model_color = ["m"]
fig, axes = plot.subplots(nrows=1, ncols=3, figsize=(15, 10), sharey=True)
for ix, svr in enumerate(svrs):
axes[ix].plot(
x,
svr.fit(x, y).predict(x),
color=model_color[ix],
lw=lw,
label="{} model".format(kernel_label[ix]),
)
axes[ix].scatter(
x[svr.support_],
y[svr.support_],
facecolor="none",
edgecolor=model_color[ix],
s=50,
label="{} support vectors".format(kernel_label[ix]),
)
axes[ix].scatter(
x[num.setdiff1d(num.arange(len(x)), svr.support_)],
y[num.setdiff1d(num.arange(len(x)), svr.support_)],
facecolor="none",
edgecolor="r",
s=50,
label="other training data",
)
fig.text(0.5, 0.04, "data", ha="center", va="center")
fig.text(0.06, 0.5, "target", ha="center", va="center", rotation="vertical")
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到非线性数据显示在屏幕上。
Scikit learn non-linear
Scikit 学习非线性回归
在本节中，我们将学习Scikit 如何在 python 中学习非线性回归工作。
- 回归被定义为有监督的机器学习技术。有两种类型的回归算法线性和非线性。
- 这里，我们可以使用非线性回归技术，该技术用于描述非线性及其取决于一个或多个独立变量的参数。
代码:
在下面的代码中，我们将学习一些库，从中我们可以创建一个非线性回归模型。
df = PDS . read _ CSV(" regression China _ GDP . CSV ")用于读取我们正在导入的文件。- plot.figure(figsize=(8，5)) 用于绘制图形。
- x_data，y_data = (df[“年”]。值，df[“值”]。【数值)用于描述数值和年份。
- plot.plot(x_data，y_data，' ro') 用于绘制 x 数据和 y 数据。
- plot.ylabel('GDP') 用于绘制 y 标签。
- plot.xlabel('Year') 用于绘制 x 标签。
import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
df = pds.read_csv("regressionchina_gdp.csv")
df.head(10)
plot.figure(figsize=(8,5))
x_data, y_data = (df["Year"].values, df["Value"].values)
plot.plot(x_data, y_data, 'ro')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()
scikit learn non-linear regression
在下面的代码中，我们选择一个模型在屏幕上绘制一个线性回归。
- plot.plot(x，y) 用于绘制屏幕上的 x 和 y。
- plot.ylabel('因变量')用于在屏幕上绘制 y 标签。
- plot . xlabel(' independent 变量')用于在屏幕上绘制 x 标签。
x = np.arange(-5.0, 5.0, 0.1)
y = 1.0 / (1.0 + np.exp(-x))
plot.plot(x,y)
plot.ylabel('Dependent Variable')
plot.xlabel('Indepdendent Variable')
plot.show()
scikit learn non-linear regression choosing a model
这里，我们可以使用逻辑函数来构建我们的非线性模型。
现在， plot.plot(x_data，Y_pred*15000000000000。)用于绘制相对于数据点的初始位置。
def sigmoid(x, Beta_1, Beta_2):
y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))
return y
beta1 = 0.10
beta2 = 1990.0
**#logistic function**
Y_pred = sigmoid(x_data, beta1 , beta2)
plot.plot(x_data, Y_pred*15000000000000.)
plot.plot(x_data, y_data, 'ro')
scikit learn non-linear regression building a model
在这里，我们可以标准化我们的数据，使曲线的最佳拟合。
- plot.figure(figsize=(8，5)) 用于在屏幕上绘制图形。
- plot.plot(xdata，ydata，' ro '，label='data') 用于在屏幕上绘制 ydata 和 xdata。
- plot.plot(x，y，linewidth=3.0，label='fit') 用于在屏幕上绘制拟合线。
xdata =x_data/max(x_data)
ydata =y_data/max(y_data)
from scipy.optimize import curve_fit
popt, pcov = curve_fit(sigmoid, xdata, ydata)
**# Now we plot our resulting regression model.**
x = np.linspace(1960, 2015, 55)
x = x/max(x)
plot.figure(figsize=(8,5))
y = sigmoid(x, *popt)
plot.plot(xdata, ydata, 'ro', label='data')
plot.plot(x,y, linewidth=3.0, label='fit')
plot.legend(loc='best')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上绘制的非线性最佳拟合线。
scikit learn non-linear regression best fit parameter
阅读: Scikit 学习决策树
Scikit 学习非线性回归示例
在本节中，我们将了解Scikit 如何学习 python 中的非线性回归示例。
非线性回归被定义为在因变量和自变量之间建立关系的二次回归。这个数据用曲线表示。
代码:
在下面的代码中，我们将导入一些库，非线性回归示例通过这些库工作。
df = PDS . read _ csv(" regression China _ GDP . CSV ")用于读取我们加载的 CSV 文件。y = 1/(1+NP . exp(-Beta _ 1 *(x-Beta _ 2)))用于定义一个 sigmoid 函数。- ypred = sigmoid(x_data，beta1，beta2) 用作逻辑函数。
- plot.plot(x_data，ypred * 1600000000000。)用于绘制数据点的初始预测。
- plot.plot(x_data，y_data，' go') 用于在图形上绘制 x_data 和 y_data。
import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
df = pds.read_csv("regressionchina_gdp.csv")
def sigmoid(x, Beta_1, Beta_2):
y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))
return y
beta1 = 0.10
beta2 = 1990.0
ypred = sigmoid(x_data, beta1, beta2)
plot.plot(x_data, ypred * 16000000000000.)
plot.plot(x_data, y_data, 'go')
输出:
运行上面的代码后，我们得到下面的输出，可以看到曲线显示了图形的非线性。
scikit learn non-linear regression example
阅读: Scikit 学习层次聚类
Scikit 学习非线性 SVM
在本节中，我们将学习scikit 如何学习 python 中的非线性 SVM 工作方式。
- 非线性 SVM 代表支持向量机，支持向量机是一种监督机器学习算法，用于分类和回归。
- 正如我们所知，非线性被定义为因变量和自变量之间的关系，它用曲线来描述模型。
代码:
在下面的代码中，我们将导入一些库，从中我们可以制作一个非线性 SVM 模型。
- x = num . randn . randn(350，2) 用于生成随机数。
- 分类器= svm。NuSVC() 用于制作 svm 分类器
- classifier.fit(x，Y) 用于拟合模型。
- Z = classifier . decision _ function(NP . c _[xx . ravel()，yy.ravel()]) 用于绘制网格上每个数据点的决策函数。
- plot.imshow(Z，interpolation='nearest '，extent=(xx.min()，xx.max()，yy.min()，yy.max())，aspect='auto '，origin='lower '，cmap=plot.cm.PuOr_r) 用于在屏幕上绘制图形。
- plot.scatter(x[:，0]，x[:，1]，s=35，c=Y，cmap=plot.cm.Paired) 用于在网格上绘制散点。
import numpy as num
import matplotlib.pyplot as plot
from sklearn import svm
xx, yy = num.meshgrid(num.linspace(-3, 3, 500),
num.linspace(-3, 3, 500))
num.random.seed(0)
x = num.random.randn(350, 2)
Y = num.logical_xor(x[:, 0] > 0, x[:, 1] > 0)
classifier = svm.NuSVC()
classifier.fit(x, Y)
Z = classifier.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plot.imshow(Z, interpolation='nearest',
extent=(xx.min(), xx.max(), yy.min(), yy.max()), aspect='auto',
origin='lower', cmap=plot.cm.PuOr_r)
contours = plot.contour(xx, yy, Z, levels=[0], linewidths=2,
linetypes='--')
plot.scatter(x[:, 0], x[:, 1], s=35, c=Y, cmap=plot.cm.Paired)
plot.xticks(())
plot.yticks(())
plot.axis([-3, 3, -3, 3])
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制了 Scikit learn 非线性 SVM 图。
scikit learn non-linear SVM
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习非线性模型
在本节中，我们将了解Scikit 如何在 python 中学习非线性模型的工作方式。
- 非线性模型根据一个或多个独立变量定义了数据及其参数之间的非线性关系。
- 非线性显示在数据点形成曲线的地方，由此证明了数据的非线性。
代码:
在下面的代码中，我们将导入一些库，从中我们可以看到非线性模型的工作原理。
range = num . random . random state(0)用于生成随机状态。- lendata =(data max–data min)用于获取数据的长度。
- data = num . sort(range . rand(n sample) lendata–lendata/2)*用于对数据进行排序，以便绘图。
- 目标=数据 * 3–0.6 数据 2 +噪声**用于制作目标。
- 完整数据= pds。DataFrame({"input feature": data，" target": target}) 用于从 DataFrame 中获取完整的数据。
- 非线性数据= sns .散点图(data=full_data，x="input feature "，y="target "，color="blue "，alpha=0.5) 用于在图形上绘制散点。
import numpy as num
range = num.random.RandomState(0)
nsample = 100
datamax, datamin = 1.5, -1.5
lendata = (datamax - datamin)
data = num.sort(range.rand(nsample) * lendata - lendata / 2)
noise = range.randn(nsample) * .3
target = data ` 3 - 0.6 * data ` 2 + noise
import pandas as pds
full_data = pds.DataFrame({"input feature": data, "target": target})
import seaborn as sns
nonlineardata = sns.scatterplot(data=full_data, x="input feature", y="target",
color="blue", alpha=0.5)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上绘制了 Scikit learn 非线性模型。
Scikit learn non-linear model
阅读: Scikit 学习岭回归
Scikit 学习非线性分类器
在本节中，我们将了解Scikit 如何学习 python 中的非线性分类器。
非线性分类器被定义为用于描述非线性及其取决于一个或多个独立变量的参数的分类过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建一个非线性分类器。
x = x.copy()用于复制数据。- x = num.random.normal(size=(n，2)) 用于生成随机数。
- xtrain，xtest，ytrain，ytest = train_test_split(x，y，random_state=0，test_size=0.5) 用于将数据集拆分为训练数据和测试数据。
- plot.figure(figsize=(5，5)) 用于在屏幕上绘制图形。
- plot.scatter(xtrain[:，0]，xtrain[:，1]，c=ytrain，edge colors = ' r ')；用于在屏幕上绘制散点图。
import numpy as num
import matplotlib.pyplot as plot
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
%config InlineBackend.figure_format = 'svg'
plot.style.use('bmh')
plot.rcParams['image.cmap'] = 'Paired_r'
num.random.seed(5)
def f(x):
x = x.copy()
x[:,0] -= 0.4
x[:,1] += 0.2
return 1.1*x[:,0]**2 + 0.3*x[:,1]**2 - 0.6*x[:,0]*x[:,1]
def makedata():
n = 800
x = num.random.normal(size=(n, 2))
y = f(x) < 0.5
x += num.random.normal(size=(n,2), scale=0.2)
return x, y
x, y = makedata()
xtrain, xtest, ytrain, ytest = train_test_split(x, y, random_state=0, test_size=0.5)
plot.figure(figsize=(5,5))
plot.scatter(xtrain[:,0], xtrain[:,1], c=ytrain, edgecolors='r');
scikit learn a non-linear classifier
在下面的代码中，我们将绘制分类器的边界。
- xx，YY = num . mesh grid(num . arange(x _ min，x_max，h)，num.arange(y_min，y_max，h)) 用于在屏幕上创建网格。
- Z = classifier . predict(num . c _[xx . ravel()，yy.ravel()]) 用于预测分类器。
- plot.figure(figsize=(5，5)) 用于在屏幕上绘制分类器。
- plot.scatter(X[:，0]，X[:，1]，c=Y，edge colors = ' r ')；用于在屏幕上绘制散点图。
- plot_boundary(classifier，xtrain，ytrain) 用于绘制分类器的边界。
- accuracy_score(ytest，classifier.predict(xtest)) 用于预测准确率得分。
def plot_boundary(classifier, X, Y):
h = 0.02
x_min, x_max = X[:,0].min() - 10*h, X[:,0].max() + 10*h
y_min, y_max = X[:,1].min() - 10*h, X[:,1].max() + 10*h
xx, yy = num.meshgrid(num.arange(x_min, x_max, h),
num.arange(y_min, y_max, h))
Z = classifier.predict(num.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plot.figure(figsize=(5,5))
plot.contourf(xx, yy, Z, alpha=0.25)
plot.contour(xx, yy, Z, colors='r', linewidths=0.7)
plot.scatter(X[:,0], X[:,1], c=Y, edgecolors='r');
from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression().fit(xtrain, ytrain)
plot_boundary(classifier, xtrain, ytrain)
accuracy_score(ytest, classifier.predict(xtest))
scikit learn non-linear classifier boundary
阅读: Scikit 学习线性回归
Scikit 学习非线性降维
在本节中，我们将了解 Scikit 如何在 python 中学习非线性降维。
非线性降维用于在不丢失任何信息的情况下减少数据集中的项目数量。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建 scikit learn 非线性降维。
- warnings . filter warnings(' ignore ')用于给出过滤器警告。
- x，y = make _ s _ curve(n _ samples = 100)用于制作曲线。
digits = load _ digits(n _ class = 6)用于加载数字。- plot.figure(figsize=(12，8)) 用于在屏幕上绘制图形。
- axis = plot . axes(projection = ' 3d ')用于在屏幕上绘制轴。
- axis.scatter3D(x[:，0]，x[:，1]，x[:，2]，c=y) 用于在图形上绘制散点图。
import sklearn
import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
from mpl_toolkits.mplot3d import Axes3D
import warnings
import sys
warnings.filterwarnings('ignore')
%matplotlib inline
from sklearn.datasets import make_s_curve
x, y = make_s_curve(n_samples=100)
from sklearn.datasets import load_digits
digits = load_digits(n_class=6)
x_digits, y_digits = digits.data, digits. target
print('Dataset Size : ', x_digits.shape, y_digits.shape)
plot.figure(figsize=(12,8))
axis = plot.axes(projection='3d')
axis.scatter3D(x[:, 0], x[:, 1], x[:, 2], c=y)
axis.view_init(10, -60);
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到非线性的维数减少。
Scikit learn non-linear dimensionality reduction
阅读: Scikit 学习超参数调整
Scikit 学习非线性 PCA
在这一节，我们将了解Scikit 如何学习 python 中的非线性 PCA 工作方式。我们将展示主成分分析和核主成分分析的区别。
- 在这里，我们通过使用一个例子来解释不同之处，在这个例子中，一方面，核主成分分析能够找到将它们线性分开的数据的投影，而这在主成分分析的情况下不会发生。
- PCA 代表主成分分析。在这个过程中，它是这个过程中使用的主要成分。也是降维方法有助于降维。
- 现在，我们通过使用投影数据解释 PCA 与 KernalPCA 的差异来解释非线性 PCA 的例子。
代码:
在下面的代码中，我们将讲述在使用 PCA 投影数据时使用内核的优势。
在这段代码中，我们生成了两个嵌套数据集。
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
x, y = make_circles(n_samples=1_000, factor=0.3, noise=0.05, random_state=0)
x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state=0)
import matplotlib.pyplot as plot
_, (train_ax1, test_ax1) = plot.subplots(ncols=2, sharex=True, sharey=True, figsize=(8, 4))
train_ax1.scatter(x_train[:, 0], x_train[:, 1], c=y_train)
train_ax1.set_ylabel("Feature 1")
train_ax1.set_xlabel("Feature 0")
train_ax1.set_title("Train data")
test_ax1.scatter(x_test[:, 0], x_test[:, 1], c=y_test)
test_ax1.set_xlabel("Feature 0")
_ = test_ax1.set_title("Test data")
输出:
运行下面的代码后，我们得到下面的输出，我们可以快速查看两个嵌套生成的数据集。
- 一个是训练数据集，另一个是测试数据集。
- 来自每个类的样本不能线性分离，因为不存在线性分离的直线，通过该直线可以分割内部数据集和外部数据集。
Scikit learn non-linear PCA
在这段代码中，我们使用了带内核和不带内核的 PCA，看看在使用内核时会有什么影响。
- 这里使用的内核是径向基函数(RBF)内核。
orig _ data _ ax1 . set _ y label()用于给测试数据的 y 轴加标签。orig _ data _ ax1 . set _ xlabel()用于给测试数据的 x 轴加标签。orig _ data _ ax1 . set _ Title()用于给测试数据的图形标题加标签。PCA _ proj _ ax1 . set _ y label()用于给PCA的 y 轴加标签。PCA _ proj _ ax1 . set _ xlabel()用于给PCA的 x 轴加标签。pca_proj_ax1.set_title()用于为PCA给出图形的标题。
from sklearn.decomposition import PCA, KernelPCA
pca1 = PCA(n_components=2)
kernel_pca1 = KernelPCA(
n_components=None, kernel="rbf", gamma=10, fit_inverse_transform=True, alpha=0.1
)
x_test_pca1 = pca1.fit(x_train).transform(x_test)
x_test_kernel_pca1 = kernel_pca1.fit(x_train).transform(x_test)
fig, (orig_data_ax1, pca_proj_ax1, kernel_pca_proj_ax1) = plot.subplots(
ncols=3, figsize=(14, 4)
)
orig_data_ax1.scatter(x_test[:, 0], x_test[:, 1], c=y_test)
orig_data_ax1.set_ylabel("Feature 1")
orig_data_ax1.set_xlabel("Feature 0")
orig_data_ax1.set_title("Testing data")
pca_proj_ax1.scatter(x_test_pca1[:, 0], x_test_pca1[:, 1], c=y_test)
pca_proj_ax1.set_ylabel("Principal component 1")
pca_proj_ax1.set_xlabel("Principal component 0")
pca_proj_ax1.set_title("projection of test data\n using PCA")
kernel_pca_proj_ax1.scatter(x_test_kernel_pca1[:, 0], x_test_kernel_pca1[:, 1], c=y_test)
kernel_pca_proj_ax1.set_ylabel("Principal component 1")
kernel_pca_proj_ax1.set_xlabel("Principal component 0")
_ = kernel_pca_proj_ax1.set_title("projection of test data using\n Kernel PCA")
输出:
运行下面的代码后，我们得到了下面的输出，在这里我们可以看到测试数据的比较，使用 PCA 的测试数据投影，以及使用 KernelPCA 的测试数据投影。
- 让我们修改一下，PCA 线性地变换数据，这意味着排列的系统将被居中，相对于它的方差重新调整所有分量，并最终被旋转。
- 查看下面的输出，我们可以在中间的结构中看到，与缩放相关的结构没有变化。
- 内核 PCA 允许进行非线性投影。
- 在这里，通过使用 RBF 核，我们期望投影将打开数据集，同时关心保持在自然空间中彼此接近的数据点对的相对距离。
- 我们可以在右边的 KernelPCA 结构中看到和观察到这样的差异。
Scikit learn non-linear Kernel PCA
你也可以阅读 Scikit learn 上的教程。
- Scikit 学习分割数据
- Scikit 学习遗传算法
- Scikit 学习分类教程
- Scikit 学习 hidden _ layer _ size
- Scikit 学习高斯教程
- Scikit 学习交叉验证
因此，在本教程中，我们讨论了 Scikit 学习非线性，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习非线性
- Scikit 学习非线性回归
- Scikit 学习非线性回归示例
- Scikit 学习非线性 SVM
- Scikit 学习非线性模型
- Scikit 学习非线性分类器
- Scikit 学习非线性降维
- Scikit 学习非线性 PCA
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习管道+示例
在这个 Python 教程中，我们将学习 Scikit 学习管道如何在 Python 中工作，我们还将涵盖与 Scikit 学习管道相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习管道
- Scikit 学习管道示例
- Scikit 学习管道自定义功能
- Scikit 了解管道的优势和劣势
- Scikit 学习管道功能选择
- Scikit 学习管道交叉验证
- Scikit 学习管道熊猫
- Scikit 学习管道酸洗
- Scikit 学习管道网格搜索
- Scikit 学习管道 one-hot 编码
目录
- Scikit 学习管道
- Scikit 学习管道示例
- Scikit 学习管道自定义功能
- Scikit 学习管道的优势和劣势
- Scikit 学习管道特征选择
- Scikit 学习管道交叉验证
- Scikit 学习管道熊猫
- Scikit 学习管道酸洗
- Scikit 学习管道网格搜索
- Scikit 学习流水线 one-hot 编码
Scikit 学习管道
在这一节中，我们将学习 Scikit 如何在 python 中学习管道工作。
管道被定义为收集数据和端到端组装的过程，该过程安排数据流，并且输出被形成为多个模型的集合。
代码:
在下面的代码中，我们将导入一些库，从中我们可以了解管道是如何工作的。
- x，y = make _ class ification(random _ state = 0)用于进行分类。
- x_train，x_test，y_train，y_test = train_test_split(x，y，random_state=0) 用于将数据集拆分为训练数据和测试数据。
- pipeline = Pipeline([('scaler '，StandardScaler())，(' svc '，SVC())]) 用作估计器，避免将测试集泄露到训练集中。
- pipeline.fit(x_train，y_train) 用于拟合模型。
- pipeline.score(x_test，y_test) 用于计算管道的得分。
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
x, y = make_classification(random_state=0)
x_train, x_test, y_train, y_test = train_test_split(x, y,
random_state=0)
pipeline = Pipeline([('scaler', StandardScaler()), ('svc', SVC())])
pipeline.fit(x_train, y_train)
pipeline.score(x_test, y_test)
输出:
在下面的输出中，我们可以看到管道模型的精度分数打印在屏幕上。
Scikit learn Pipeline
阅读: Scikit 学习 KNN 教程
Scikit 学习管道示例
在本节中，我们将了解Scikit 如何学习 python 中的管道示例。
管道是端到端的加密数据，并且还安排数据流，并且输出形成为一组多个模型。
代码:
在下面的代码中，我们将导入一些库，借助例子来解释管道模型。
iris = datasets . load _ iris()用于将数据导入 sklearn 进行虹膜分类。- x_train，x_test，y_train，y_test = train_test_split(x，y，test_size = 0.25) 用于将数据集拆分为训练数据和测试数据。
- pipeline = Pipeline([('pca '，PCA(n_components = 4))，(' std '，StandardScaler())，(' Decision_tree '，Decision tree classifier()]，verbose = True) 用于制作管道。
- pipeline.fit(x_train，y_train) 用于拟合模型。
pipeline.get_params()用于查看所有的超参数。
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.tree import DecisionTreeClassifier
iris = datasets.load_iris()
x = iris.data
y = iris.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.25)
from sklearn.pipeline import Pipeline
pipeline = Pipeline([('pca', PCA(n_components = 4)), ('std', StandardScaler()), ('Decision_tree', DecisionTreeClassifier())], verbose = True)
pipeline.fit(x_train, y_train)
# to see all the hyper parameters
pipeline.get_params()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到所有的超参数都显示在屏幕上，这些参数是在管道中传递的类中设置的。
scikit learn pipeline example
阅读: Scikit 学习情绪分析
Scikit 学习管道自定义功能
在本节中，我们将了解scikit 如何学习 python 中的管道自定义函数。
Scikit learn 自定义函数用于返回二维数组的值或者也用于删除离群值。
代码:
在下面的代码中，我们将导入一些库，从中我们可以解释管道自定义函数。
- zip file _ path = OS . path . join(our _ path，" housing.tgz") 用于设置 zip 文件的路径。
- url lib . request . URL retrieve(our _ data _ URL，zipfile_path) 用于从 URL 获取文件。
- our file _ path = OS . path . join(our _ path，" housing.csv") 用于设置 csv 文件路径。
return PDS . read _ CSV(our file _ path)用于读取熊猫文件。imputr = simple imputr(strategy = " median ")用于计算每列的中间值。- our dataset _ num = our _ dataset . drop(" ocean _ proximity "，axis=1) 用于移除海洋邻近度。
inputr . fit(our dataset _ num)用于拟合模型。- our _ text _ cats = our _ dataset[[' ocean _ proximity ']]用于选择文本属性。
- rooms_per_household = x[:，rooms] / x[:，household] 用于通过划分适当的属性得到三个额外的属性。
import os
import tarfile
from six.moves import urllib
OURROOT_URL = "https://raw.githubusercontent.com/ageron/handson-ml/master/"
OURPATH = "datasets/housing"
OURDATA_URL = OURROOT_URL + OURPATH + "/housing.tgz"
def get_data(our_data_url=OURDATA_URL, our_path=OURPATH):
if not os.path.isdir(our_path):
os.makedirs(our_path)
zipfile_path = os.path.join(our_path, "housing.tgz")
urllib.request.urlretrieve(our_data_url, zipfile_path)
ourzip_file = tarfile.open(zipfile_path)
ourzip_file.extractall(path=our_path)
ourzip_file.close()
get_data()
import pandas as pds
def loadour_data(our_path=OUR_PATH):
ourfile_path = os.path.join(our_path, "housing.csv")
return pds.read_csv(ourfile_path)
ourdataset = load_our_data()
ourdataset.head()
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy="median")
ourdataset_num = our_dataset.drop("ocean_proximity", axis=1)
imputer.fit(ourdataset_num)
**#transforming using the learnedparameters**
x = imputer.transform(ourdataset_num)
**#setting the transformed dataset to a DataFrame**
ourdataset_numeric = pds.DataFrame(x, columns=ourdataset_num.columns)
from sklearn.preprocessing import OrdinalEncoder
our_text_cats = our_dataset[['ocean_proximity']]
our_encoder = OrdinalEncoder()
**#transforming it**
our_encoded_dataset = our_encoder.fit_transform(our_text_cats)
import numpy as num
from sklearn.base import BaseEstimator, TransformerMixin
**#initialising column numbers**
rooms, bedrooms, population, household = 4,5,6,7
class CustomTransformer(BaseEstimator, TransformerMixin):
**#the constructor**
def __init__(self, add_bedrooms_per_room = True):
self.add_bedrooms_per_room = add_bedrooms_per_room
** #estimator method**
def fit(self, x, y = None):
return self
** #transfprmation**
def transform(self, x, y = None):
rooms_per_household = x[:, rooms] / x[:, household]
population_per_household = x[:, population] / x[:, household]
if self.add_bedrooms_per_room:
bedrooms_per_room = x[:, bedrooms] / x[:, rooms]
return num.c_[x, rooms_per_household, population_per_household, bedrooms_per_room]
else:
return num.c_[x, rooms_per_household, population_per_household]
attrib_adder = CustomTransformer()
our_extra_attributes = attrib_adder.transform(our_dataset.values)
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
**#the numeric attributes transformation pipeline**
numericpipeline = Pipeline([
('imputer', SimpleImputer(strategy="median")),
('attribs_adder', CustomTransformer()),
])
numericattributes = list(our_dataset_numeric)
**#the textual transformation pipeline**
text_attribs = ["ocean_proximity"]
#setting the order of the two pipelines
our_full_pipeline = ColumnTransformer([
("numeric", numericpipeline, numericattributes),
("text", OrdinalEncoder(), text_attribs),
])
our_dataset_prepared = our_full_pipeline.fit_transform(our_dataset)
our_dataset_prepared
输出:
在下面的输出中，我们可以看到管道自定义函数返回值的二维数组。
scikit learn pipeline custom function
阅读: Scikit 学习梯度下降
Scikit 学习管道的优势和劣势
在本节中，我们将学习 Python 中的 scikit learn pipeline 优缺点。
Scikit 学习管道的优势
sci kit learn pipeline 是一个工具，它使我们的工作变得非常容易，我们可以很快理解所有事情。
- 它应用步骤的实现和顺序。
- 它可以收集数据和收集数据的过程。数据可以是实时的，也可以是各种来源的集合数据。
- 它可以支持松弛通知
- 它可以提供分布式计算选项。
sci kit 学习管道的缺点
- 它不支持自动管道选项。
- 它没有设计成在不使用数据库的情况下在相关任务之间传递数据。
阅读: Scikit 学习遗传算法
Scikit 学管道特征选择
在本节中，我们将学习scikit 如何在 python 中学习管道特性选择。
特征选择被定义为选择特征或重复选择管线特征的方法。
代码:
在下面的代码中，我们将导入一些库，从中我们可以选择管道的特征。
- x，y = make_classification() 用于进行分类。
- x_train，x_test，y_train，y_test = train_test_split(x，y，random_state=42) 用于将数据集拆分为训练和测试数据。
- ANOVA filter = selectk best(f _ classif，k=5) 用于选择最佳特征。
- ANOVA _ SVM = make _ pipeline(ANOVA _ filter，classifier) 用于制作管道。
- anova_svm.fit(x_train，y_train) 用于拟合模型。
- 打印(classification_report(y_test，y_pred)) 用于打印分类报告。
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
x, y = make_classification(
n_features=22,
n_informative=5,
n_redundant=0,
n_classes=4,
n_clusters_per_class=4,
random_state=44,
)
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=42)
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.pipeline import make_pipeline
from sklearn.svm import LinearSVC
anovafilter = SelectKBest(f_classif, k=5)
classifier = LinearSVC()
anova_svm = make_pipeline(anova_filter, classifier)
anova_svm.fit(x_train, y_train)
from sklearn.metrics import classification_report
y_pred = anova_svm.predict(x_test)
print(classification_report(y_test, y_pred))
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上显示了选择功能。
scikit learn pipeline feature selection
阅读: Scikit 学习分类教程
Scikit 学习管道交叉验证
在本节中，我们将学习Scikit 如何在 python 中学习管道交叉验证。
Scikit learn pipeline 交叉验证技术被定义为评估静态模型结果的过程，该结果将扩展到看不见的数据。
代码:
在下面的代码中，我们将导入一些库，从中我们可以解释管道交叉验证模型。
- best score _ idx = num . arg max(cv _ result[" mean _ test _ score "])用于计算最佳得分。
threshold = lower _ bound(cv _ result)用于计算下限模型的阈值。- best _ idx = candidate _ idx[cv _ result[" param _ reduce _ dim _ _ n _ components "]用于计算交叉验证的结果。
- param _ grid = { " reduce _ dim _ _ n _ components ":[6，8，10，12，14]} 用于计算参数网格。
- x，y = load _ digits(return _ X _ y = True)用于加载数字。
- plot.bar(n_components，test_scores，width=1.4，color="r") 用于绘制条形。
- plot.title("平衡模型复杂度和交叉验证分数")用于绘制图形的标题。
- print(" best _ index _ is % d " % best _ index _)用于在屏幕上绘制最佳索引网格。
import numpy as num
import matplotlib.pyplot as plot
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
def lower_bound(cv_result):
bestscore_idx = num.argmax(cv_result["mean_test_score"])
return (
cv_result["mean_test_score"][bestscore_idx]
- cv_result["std_test_score"][bestscore_idx]
)
def best_low_complexity(cv_result):
threshold = lower_bound(cv_result)
candidate_idx = num.flatnonzero(cv_result["mean_test_score"] >= threshold)
best_idx = candidate_idx[
cv_result["param_reduce_dim__n_components"][candidate_idx].argmin()
]
return best_idx
pipeline = Pipeline(
[
("reduce_dim", PCA(random_state=42)),
("classify", LinearSVC(random_state=42, C=0.01)),
]
)
param_grid = {"reduce_dim__n_components": [6, 8, 10, 12, 14]}
grid = GridSearchCV(
pipeline,
cv=10,
n_jobs=1,
param_grid=param_grid,
scoring="accuracy",
refit=best_low_complexity,
)
x, y = load_digits(return_X_y=True)
grid.fit(X, y)
n_components = grid.cv_results_["param_reduce_dim__n_components"]
test_scores = grid.cv_results_["mean_test_score"]
plot.figure()
plot.bar(n_components, test_scores, width=1.4, color="r")
lower = lower_bound(grid.cv_results_)
plot.axhline(np.max(test_scores), linestyle="--", color="y", label="Best score")
plot.axhline(lower, linestyle="--", color=".6", label="Best score - 1 std")
plot.title("Balance Model Complexity And Cross-validated Score")
plot.xlabel("Number Of PCA Components Used")
plot.ylabel("Digit Classification Accuracy")
plot.xticks(n_components.tolist())
plot.ylim((0, 1.0))
plot.legend(loc="upper left")
best_index_ = grid.best_index_
print("The best_index_ is %d" % best_index_)
print("The n_components selected is %d" % n_components[best_index_])
print(
"The corresponding accuracy score is %.2f"
% grid.cv_results_["mean_test_score"][best_index_]
)
plot.show()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到管道交叉验证分数打印在屏幕上。
scikit learn pipeline cross-validation
阅读: Scikit 学习超参数调整
Scikit 学习管道熊猫
在这一节中，我们将学习Scikit 如何在 python 中学习 pipeline pandas 的工作方式。
Scikit learn pipeline pandas 被定义为一个允许我们将各种用户定义的函数串在一起以构建管道的过程。
代码:
在下面的代码中，我们将导入一些库，在熊猫的帮助下，我们可以从这些库中绘制管道。
pca = pca()用于定义一个流水线来搜索 PCA 的最佳组合。scaler = StandardScaler()用于定义一个标准的 scaler 来归一化输入。- pipeline = Pipeline(步骤=[("scaler "，scaler)，(" pca "，pca)，(" logistic "，logisticregr)]) 用于定义流水线的步骤。
- search grid = GridSearchCV(pipeline，param_grid，n_jobs=2) 用于定义网格搜索。
- print("最佳参数(CV 分数= % 0.3f):" % search grid . Best _ score _)用于定义最佳参数分数。
pca.fit(x_digits)用于拟合模型。
import numpy as num
import matplotlib.pyplot as plot
import pandas as pds
from sklearn import datasets
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
pca = PCA()
scaler = StandardScaler()
logisticregr = LogisticRegression(max_iter=10000, tol=0.2)
pipeline = Pipeline(steps=[("scaler", scaler), ("pca", pca), ("logistic", logisticregr)])
x_digits, y_digits = datasets.load_digits(return_X_y=True)
param_grid = {
"pca__n_components": [5, 15, 30, 45, 60],
"logistic__C": np.logspace(-4, 4, 4),
}
searchgrid = GridSearchCV(pipeline, param_grid, n_jobs=2)
searchgrid.fit(x_digits, y_digits)
print("Best parameter (CV score=%0.3f):" % searchgrid.best_score_)
print(searchgrid.best_params_)
pca.fit(x_digits)
fig, (axis0, axis1) = plot.subplots(nrows=2, sharex=True, figsize=(6, 6))
axis0.plot(
num.arange(1, pca.n_components_ + 1), pca.explained_variance_ratio_, "+", linewidth=2
)
axis0.set_ylabel("PCA explained variance ratio")
axis0.axvline(
searchgrid.best_estimator_.named_steps["pca"].n_components,
linestyle=":",
label="n_components chosen",
)
axis0.legend(prop=dict(size=12))
**# For each number of components, find the best classifier results**
results = pds.DataFrame(searchgrid.cv_results_)
components_col = "param_pca__n_components"
best_classifications = results.groupby(components_col).apply(
lambda g: g.nlargest(1, "mean_test_score")
)
best_classifications.plot(
x=components_col, y="mean_test_score", yerr="std_test_score", legend=False, ax=axis1
)
axis1.set_ylabel("Classification accuracy (val)")
axis1.set_xlabel("n_components")
plot.xlim(-1, 70)
plot.tight_layout()
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到管道是在 pandas 的帮助下绘制的。
scikit learn pipeline pandas
阅读: Scikit 学习线性回归+例题
Scikit 学习管道酸洗
在这一节中，我们将了解Scikit 如何在 python 中学习 pipeline pickle 的工作方式。
Scikit 学习管道 pickle 被定义为一个定期保存文件的过程，或者我们可以说是序列化对象的方式。
代码:
在下面的代码中，我们将导入一些库，在 pickle 的帮助下，我们可以从这些库中序列化数据。
- x_train = num.array([[3，9，6]，[5，8，3]，[2，10，5]]) 用于创建一些数据。
- pipeline.fit(x_train，y_train) 用于训练模型。
- model = pipeline . named _ steps[' randomforestclassifier ']用于酸洗模型。
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import make_pipeline
import pickle
import numpy as num
pipeline = make_pipeline(
RandomForestClassifier(),
)
x_train = num.array([[3,9,6],[5,8,3],[2,10,5]])
y_train = num.array([27, 30, 19])
pipeline.fit(x_train, y_train)
model = pipeline.named_steps['randomforestclassifier']
outfile = open("model.pkl", "wb")
pickle.dump(model, outfile)
outfile.close()
model
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上显示了 Scikit 学习管道 pickle。
Scikit learn Pipeline Pickle
阅读: Scikit 学习功能选择
Scikit 学习管道网格搜索
在本节中，我们将了解 Scikit learn pipeline grid search 如何在 python 中工作。
Scikit learn pipeline grid search 是一种定义超参数的操作，它告诉用户模型的准确率。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算模型的准确率。
- n_feature_options = [4，8，12] 用于创建特征选项。
- grid = GridSearchCV(pipeline，n_jobs=1，param_grid=param_grid) 用于创建网格搜索。
mean _ scores = mean _ scores . max(axis = 0)用于选择最佳 c 的得分- plot.bar(bar_offsets + i，reducer_scores，label=label，color=COLORS[i]) 用于在图形上绘制条形。
- plot.title("比较特征缩减技术")用于在图上绘制标题。
import numpy as num
import matplotlib.pyplot as plot
from sklearn.datasets import load_digits
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
from sklearn.decomposition import PCA, NMF
from sklearn.feature_selection import SelectKBest, chi2
pipeline = Pipeline(
[
**# the reduce_dim stage is populated by the param_grid**
("reduce_dim", "passthrough"),
("classify", LinearSVC(dual=False, max_iter=10000)),
]
)
n_feature_options = [4, 8, 12]
c_options = [1, 10, 100, 1000]
param_grid = [
{
"reduce_dim": [PCA(iterated_power=7), NMF()],
"reduce_dim__n_components": n_feature_options,
"classify__C": c_options,
},
{
"reduce_dim": [SelectKBest(chi2)],
"reduce_dim__k": n_feature_options,
"classify__C": c_options,
},
]
reducer_labels = ["PCA", "NMF", "KBest(chi2)"]
grid = GridSearchCV(pipeline, n_jobs=1, param_grid=param_grid)
x, y = load_digits(return_X_y=True)
grid.fit(x, y)
mean_scores = num.array(grid.cv_results_["mean_test_score"])
mean_scores = mean_scores.reshape(len(c_options), -1, len(n_feature_options))
mean_scores = mean_scores.max(axis=0)
bar_offsets = np.arange(len(n_feature_options)) * (len(reducer_labels) + 1) + 0.5
plot.figure()
COLORS = "cyr"
for i, (label, reducer_scores) in enumerate(zip(reducer_labels, mean_scores)):
plot.bar(bar_offsets + i, reducer_scores, label=label, color=COLORS[i])
plot.title("Comparing Feature Reduction Techniques")
plot.xlabel("Reduced Number Of Features")
plot.xticks(bar_offsets + len(reducer_labels) / 2, n_feature_options)
plot.ylabel("Digit Classification Accuracy")
plot.ylim((0, 1))
plot.legend(loc="Upper Left")
plot.show()
输出:
在下面的输出中，我们可以看到屏幕上绘制了 scikit 学习管道网格搜索栏。
scikit learn pipeline grid search
阅读: Scikit 学习岭回归
Scikit 学习流水线 one-hot 编码
在本节中，我们将了解Scikit 如何学习 python 中的管道一热编码工作。
Scikit 学习管道 one-hot 编码被定义或表示分类变量。在这种情况下，对分类变量的需求被映射为整数值。
代码:
在下面的代码中，我们将导入一些库，从中我们可以进行一次性编码。
- y = range . poisson(lam = num . exp(x[:，5]) / 2) 用于获取正的整数目标。
- x_train，x_test，y_train，y_test = train_test_split(x，y，random_state=range) 用于将数据集拆分成测试数据或训练数据。
set _ config(display = " diagram ")用于配置数据。- num _ proc = make _ pipeline(simple imputr(strategy = " median ")，StandardScaler()) 用于制作管道。
import numpy as num
from sklearn.model_selection import train_test_split
from sklearn.linear_model import PoissonRegressor
from sklearn.ensemble import HistGradientBoostingRegressor
nsamples, nfeatures = 1000, 20
range = num.random.RandomState(0)
x = range.randn(nsamples, nfeatures)
y = range.poisson(lam=num.exp(x[:, 5]) / 2)
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=range)
glm = PoissonRegressor()
gbdt = HistGradientBoostingRegressor(loss="poisson", learning_rate=0.01)
glm.fit(x_train, y_train)
gbdt.fit(x_train, y_train)
print(glm.score(x_test, y_test))
print(gbdt.score(x_test, y_test))
from sklearn import set_config
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.compose import make_column_transformer
from sklearn.linear_model import LogisticRegression
set_config(display="diagram")
num_proc = make_pipeline(SimpleImputer(strategy="median"), StandardScaler())
cat_proc = make_pipeline(
SimpleImputer(strategy="constant", fill_value="missing"),
OneHotEncoder(handle_unknown="ignore"),
)
preprocessor = make_column_transformer(
(num_proc, ("feat1", "feat3")), (cat_proc, ("feat0", "feat2"))
)
classifier = make_pipeline(preprocessor, LogisticRegression())
classifier
输出:
运行上述代码后，我们得到以下输出，从中可以看到屏幕上完成了 scikit 学习管道 one-hot 编码。
scikit learn pipeline one-hot encoding
您可能还想阅读以下 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit 学习管道,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习管道
- Scikit 学习管道示例
- Scikit 学习管道自定义功能
- Scikit 了解管道的优势和劣势
- Scikit 学习管道功能选择
- Scikit 学习管道交叉验证
- Scikit 学习管道熊猫
- Scikit 学习管道酸洗
- Scikit 学习管道网格搜索
- Scikit 学习管道 one-hot 编码
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习随机森林
在这个 Python 教程中，我们将学习如何在 Python 中创建一个 scikit 学习随机森林，我们还将涵盖与随机森林相关的不同示例。我们将讨论这些话题。
- Scikit 学习随机森林
- Scikit 学习随机森林示例
- Scikit 学习随机森林回归
- Scikit 学习随机森林超参数调整
- Scikit 学习随机森林特征重要性
- Scikit 学习随机森林分类变量
- Scikit 学习随机森林交叉验证
- Scikit 学习随机森林可视化
目录
- Scikit 学习随机森林
- Scikit 学习随机森林示例
- Scikit 学习随机森林回归
- Scikit 学习随机森林超参数调整
- Scikit 学习随机森林特征重要性
- Scikit 学习随机森林分类变量
- Scikit 学习随机森林交叉验证
- Scikit 学习随机森林可视化
Scikit 学习随机森林
在这一节中，我们将学习如何用 python 让 scikit 学习随机森林。
- 随机森林是一种受监督的机器学习模型，用于解决回归或分类问题。
- 它是一种结合许多分类器的技术，以简单的方式解决困难或复杂的问题。
- 它基于决策树的预测生成结果，该决策树通过取许多树的输出的平均值来进行预测。
- 它也有一个限制，即减少数据集的过拟合，提高精度。
scikit learn Random Forest
另外，检查: Scikit-learn 逻辑回归
Scikit 学习随机森林示例
在本节中，我们将学习如何创建一个 scikit 学习python 中的随机森林示例。
- 随机森林是一种受监督的机器学习模型，用于分类、回归和所有其他使用决策树的任务。
- 随机森林产生一组随机选择训练集子集的决策树。
代码:
在下面的代码中，我们将从 sklearn 导入数据集，并创建一个随机森林分类器。
iris = datasets . load _ iris()用于加载 iris 数据集。- X，y = datasets . load _ iris(return _ X _ y = True)用于将数据集分为训练数据集和测试数据集两部分。
from sk learn . model _ selection import train _ test _ split用于切割随机训练或测试子集中的数组。- X_train，X_test，y_train，y_test = train_test_split(X，y，test_size = 0.30) 这里有 70%的训练数据集和 30%的测试数据集。
from sklearn import datasets
iris = datasets.load_iris()
print(iris.target_names)
print(iris.feature_names)
X, y = datasets.load_iris( return_X_y = True)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30)
运行上述代码后，我们得到以下输出，其中我们可以看到数据集的特征显示在屏幕上。
scikit learn a random forest dataset
print(data.head()) 用于在屏幕上打印数据集的前五行。
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
data = pd.DataFrame({'sepallength' : iris.data[:,0],'sepalwidth' : iris.data[:,1], 'petallength' : iris.data[:,2], 'petalwidth' : iris.data[:,3],'species' : iris.target})
print(data.head())
运行上面的代码后，我们得到下面的输出，我们可以看到前五行打印在屏幕上。
scikit learn random forest import dataset
classifier = RandomForestClassifier(n _ estimators = 100)用于创建随机森林分类器。- classifier.fit(X_train，y_train) 用于拟合函数，使用训练集训练模型。
y _ pred = classifier . predict(X _ test)用于对测试数据集进行预测。- 从 sklearn 导入指标用于从指标中找出准确度或误差。
- print("模型精度: "，metrics.accuracy_score(y_test，y_pred)) 用于打印计算后的模型精度。
classifier = RandomForestClassifier(n_estimators = 100)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
from sklearn import metrics
print()
print("Accuracy of the model: ", metrics.accuracy_score(y_test, y_pred))
在这张图片中，我们可以看到随机森林模型的准确性。
scikit learn random forest accuracy
阅读:Scikit-learn Vs tensor flow–详细对比
Scikit 学习随机森林回归
在本节中，我们将学习 python 中的scikit learn random forest regression。
随机森林是一种受监督的机器学习算法，它是一种合并许多分类器以提供困难问题解决方案的技术，类似于回归方法。
代码:
在下面的代码中，我们将导入 sklearn 库，从中我们可以创建一个随机森林回归。
- x，y = make_regression(n_features=4，n _ informative = 2，random_state=0，shuffle=False) 用于进行随机森林回归。
- print(regression . predict([[0，0，0，0]])用于预测回归。
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
x, y = make_regression(n_features=4, n_informative=2,
random_state=0, shuffle=False)
regression = RandomForestRegressor(max_depth=2, random_state=0)
regression.fit(x, y)
RandomForestRegressor(...)
print(regression.predict([[0, 0, 0, 0]]))
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到随机森林回归预测。
scikit learn random forest regression
阅读: Scikit 学习决策树
Scikit 学习随机森林超参数调整
在本节中，我们将了解如何让 scikit 学习 python 中的随机森林超参数调整。
随机森林超参数调整涉及森林中的若干决策树和每棵树在被分割成不同部分时所考虑的若干特征。
代码:
在下面的代码中，我们将从 sklearn.esemble 导入 RandomForestRegressor ，并且从 print 导入print。
print(' Parameters currently in use:\ n ')用于打印当前森林使用的当前参数。
from sklearn.ensemble import RandomForestRegressor
rf = RandomForestRegressor(random_state = 42)
from pprint import pprint
print('Parameters currently in use:\n')
pprint(rf.get_params())
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到当前的参数被打印在屏幕上。
Random forest hyperparameter tunning current parameter
- n _ estimators =[int(x)for x in NP . Lin space(start = 200，stop = 2000，num = 10)] 它解释了随机森林中树的数量。
- max_features = ['auto '，' sqrt'] 这是每次分割时要考虑的特征数量。
- max _ depth =[int(x)for x in NP . Lin space(10，110，num = 11)] 是树中的最大层数。
- min_samples_split = [2，5，10] 是分裂一个节点所需的最小样本数。
- min_samples_leaf = [1，2，4] 是每个叶节点所需的最小样本数。
from sklearn.model_selection import RandomizedSearchCV
import numpy as np
n_estimators = [int(x) for x in np.linspace(start = 200, stop = 2000, num = 10)]
max_features = ['auto', 'sqrt']
max_depth = [int(x) for x in np.linspace(10, 110, num = 11)]
max_depth.append(None)
min_samples_split = [2, 5, 10]
min_samples_leaf = [1, 2, 4]
bootstrap = [True, False]
random_grid = {'n_estimators': n_estimators,
'max_features': max_features,
'max_depth': max_depth,
'min_samples_split': min_samples_split,
'min_samples_leaf': min_samples_leaf,
'bootstrap': bootstrap}
pprint(random_grid)
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上创建了一个 scikit learn 超参数调整。
scikit learn random forest hyperparameter tunning
Scikit 学习随机森林特征重要性
在本节中，我们将了解如何用 python 创建sci kit learn random forest feature importance。
- 特征重要性是描述整个过程的最佳方式。它描述了哪些特性是相关的，哪些是不相关的。
- 它还有助于以更好的方式理解所解决的问题，并且有时通过使用特征选择来进行模型改进。
代码:
在下面的代码中，我们将导入一些用于创建随机森林的库，并借助特性重要性来描述特性。
- classifier.predict([[3，3，2，2]]) 用于预测是哪种类型的花。
classifier = RandomForestClassifier(n _ estimators = 100)用于创建随机森林分类器。- classifier.fit(X_train，y_train) 用于训练集对模型进行训练。
- feature_imp = pd。series(classifier . feature _ importances _，index=iris.feature_names)。sort _ values(ascending = False)使用特征重要性变量来描述模型的特征。
from sklearn import datasets
iris = datasets.load_iris()
print(iris.target_names)
print(iris.feature_names)
X, y = datasets.load_iris( return_X_y = True)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30)
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
data = pd.DataFrame({'sepallength' : iris.data[:,0],'sepalwidth' : iris.data[:,1], 'petallength' : iris.data[:,2], 'petalwidth' : iris.data[:,3],'species' : iris.target})
print(data.head())
classifier = RandomForestClassifier(n_estimators = 100)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
from sklearn import metrics
print()
print("Accuracy of the model: ", metrics.accuracy_score(y_test, y_pred))
classifier.predict([[3, 3, 2, 2]])
from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators = 100)
classifier.fit(X_train, y_train)
import pandas as pd
feature_imp = pd.Series(classifier.feature_importances_, index = iris.feature_names).sort_values(ascending = False)
feature_imp
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到模型的特性是由特性重要性描述的。
scikit learn random forest feature importance
阅读: Scikit 学习隐马尔可夫模型
Scikit 学习随机森林分类变量
在本节中，我们将了解如何让 scikit 学习随机森林分类变量。
- 分类变量是指我们可以将变量分配到特定组的变量。
- 分类变量只能取两个值作为二进制值，而二进制值只首选 0 和 1。
代码:
在下面的代码中，我们将导入熊猫作为 pd，并从中读取数据。
import pandas as pd
df = pd.read_csv('bank.csv')
df.head()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到数据集的前五行显示在屏幕上。
scikit learn random forest categorical variable data
在下面的代码中，我们打印我们将变量分配给特定组的类别中的变量。
s = (df.dtypes == 'object')
object_cols = list(s[s].index)
print("Categorical variables:")
print(object_cols)
运行上面的代码后，我们得到下面的输出，其中我们可以看到分类变量的 object 列显示在屏幕上。
scikit learn random forest categorical variable object column
这里我们可以看到变量被分配给了一个特定的组。
features = df[['Sex','Housing','Saving accounts']]
features.head()
scikit learn random forest categorical variable
阅读: Scikit 学习功能选择
Scikit 学习随机森林交叉验证
在本节中，我们将学习 python 中的 scikit learn random forest 交叉验证。
- 交叉验证是用于评估模型的性能或准确性的过程。它还用于防止模型在预测模型中过度拟合。
- 交叉验证我们可以对数据进行固定次数的折叠，并对数据进行分析。
scikit-learn.org
阅读: Scikit 学习线性回归
Scikit 学习随机森林可视化
在这一节中，我们将学习如何让 scikit 学习 python 中的随机森林 虚拟化。
- 正如我们所知，随机森林在几个决策树上工作。绘制它们，看看模型如何预测目标变量的值。
- 可视化是一个随机挑选 2 或 3 棵树的过程，它给模型一个很好的直觉。
代码:
在下面的代码中，我们将导入库，从中我们可以进行随机的森林可视化。
model = RandomForestClassifier(n _ estimators = 10)用于制作模型，也可以使用单决策树。- estimator = model . estimators _[5]用于提取单棵树。
- 调用(['dot '，'-Tpng '，' tree.dot '，'-o '，' tree.png '，'-Gdpi=600']) 用于使用系统命令转换成 png。
from sklearn.datasets import load_iris
iris = load_iris()
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=10)
model.fit(iris.data, iris.target)
estimator = model.estimators_[5]
from sklearn.tree import export_graphviz
export_graphviz(estimator, out_file='tree.dot',
feature_names = iris.feature_names,
class_names = iris.target_names,
rounded = True, proportion = False,
precision = 2, filled = True)
from subprocess import call
call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])
from IPython.display import Image
Image(filename = 'tree.png')
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 scikit learn random forest 可视化是在屏幕上完成的。
scikit learn random forest visualization
您可能还想阅读以下 scikit 学习教程。
因此，在本教程中，我们讨论了 python 中的 Scikit learn random forest ，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习随机森林
- Scikit 学习随机森林示例
- Scikit 学习随机森林回归
- scikit 学习随机森林超参数调整
- Scikit 学习随机森林特征重要性
- Scikit 学习随机森林分类变量
- Scikit 学习随机森林交叉验证
- Scikit 学习随机森林可视化
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习岭回归
在这个 Python 教程中，我们将学习如何在 Python 中创建 scikit learn ridge regression ，我们还将涵盖与 ridge regression 相关的不同示例。我们将讨论这些话题。
- Scikit 学习岭回归
- Scikit 学习岭回归系数
- Scikit 学习核岭回归
- Scikit 学习贝叶斯岭回归
目录
Scikit 学岭回归
本节我们将学习如何解决 python 中的 Scikit 学习 岭回归。
岭回归用于求解该回归模型，并通过添加一些等价于系数大小平方的惩罚来修改损失函数。
代码:
在下面的代码中，我们将导入一些库，从中我们可以用 python 求解岭回归。
- n_samples，n_features = 15，10 用于在此岭函数中添加样本和特征。
RNG = NP . random . random state(0)用于随机状态。- rdg.fit(X，y) 用于拟合数值。
from sklearn.linear_model import Ridge
import numpy as np
n_samples, n_features = 15, 10
range = np.random.RandomState(0)
y = range.randn(n_samples)
X = range.randn(n_samples, n_features)
ridge = Ridge(alpha = 0.5)
ridge.fit(X, y)
ridge.score(X,y)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上显示了岭回归得分。
Scikit learn Ridge Regression
另外，检查: Scikit-learn Vs Tensorflow
Scikit 学岭回归系数
在本节中，我们将了解如何用 python 创建 scikit learn 岭回归系数。
代码:
在下面的代码中，我们将从 sklearn.learn 中导入 ridge 库，还将导入 numpy 作为 np 。
- n_samples，n_features = 15，10 用于在岭函数中添加样本和特征。
- ridge.score(X，y) 用于给出得到分数的岭函数。
ridge.coef_用于获取岭函数的系数。
from sklearn.linear_model import Ridge
import numpy as np
n_samples, n_features = 15, 10
range = np.random.RandomState(0)
y = range.randn(n_samples)
X = range.randn(n_samples, n_features)
ridge = Ridge(alpha = 0.5)
ridge.fit(X, y)
ridge.score(X,y)
ridge.coef_
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到脊系数打印在屏幕上。
scikit learn ridge regression coefficient
Scikit 学习内核岭回归
在这一节中，我们将学习如何用 Python 创建一个 scikit learn 内核脊回归。
内核岭回归用自己的招数合并岭回归。核包括线性函数中的空间。
代码:
在下面的代码中，我们将从 sklearn.kernel_ridge 导入 KernelRidge，从中我们可以得到内核脊值。
- n_samples，n_features = 10，5 用于创建样本和特征的核脊。
KernelRidge(alpha=1.0)用于获取核脊值。
from sklearn.kernel_ridge import KernelRidge
import numpy as np
n_samples, n_features = 10, 5
range = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)
kernel = KernelRidge(alpha=1.0)
kernel.fit(X, y)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上显示了内核脊值。
scikit learn kernel ridge regression
阅读: Scikit 学习决策树
Scikit 学习贝叶斯岭回归
在这一节中，我们将学习如何用 Python 创建一个 scikit 学习贝叶斯岭回归。
贝叶斯回归允许自然机制通过使用概率公式化线性回归来保持不充分的分布数据。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建贝叶斯岭回归。
- n_samples，n_features = 100，100 用于生成数据。
- X = np.random.randn(n_samples，n_features) 用于创建高斯数据。
lambda_ = 4.0用于创建带有 lambda 值的权重。- relevant _ features = NP . random . randint(0，n_features，10) 用于保持 10 个感兴趣的权重。
clf = Bayesian ridge(compute _ score = True)用于拟合贝叶斯回归。- plot.figure(figsize=(6，5)) 用于绘制图形。
import numpy as np
import matplotlib.pyplot as plot
from scipy import stats
from sklearn.linear_model import BayesianRidge, LinearRegression
np.random.seed(0)
n_samples, n_features = 100, 100
X = np.random.randn(n_samples, n_features) # Create Gaussian data
lambda_ = 4.0
w = np.zeros(n_features)
relevant_features = np.random.randint(0, n_features, 10)
for i in relevant_features:
w[i] = stats.norm.rvs(loc=0, scale=1.0 / np.sqrt(lambda_)).
alpha_ = 50.0
noise = stats.norm.rvs(loc=0, scale=1.0 / np.sqrt(alpha_), size=n_samples)
y = np.dot(X, w) + noise
clf = BayesianRidge(compute_score=True)
clf.fit(X, y)
ols = LinearRegression()
ols.fit(X, y)
lw = 2
plot.figure(figsize=(6, 5))
plot.title("Weights of model")
plot.plot(clf.coef_, color="green", linewidth=lw, label="Bayesian Ridge estimate")
plot.plot(w, color="yellow", linewidth=lw, label="Ground truth")
plot.plot(ols.coef_, color="red", linestyle="--", label="OLS estimate")
plot.xlabel("Features")
plot.ylabel("Values of weights")
plot.legend(loc="best", prop=dict(size=12))
plot.figure(figsize=(6, 5))
plot.title("Histogram of weights")
plot.hist(clf.coef_, bins=n_features, color="gold", log=True, edgecolor="black")
plot.scatter(
clf.coef_[relevant_features],
np.full(len(relevant_features), 5.0),
color="navy",
label="Relevant features",
)
plot.ylabel("Features")
plot.xlabel("Values of weights")
plot.legend(loc="upper left")
plot.figure(figsize=(6, 5))
plot.title("Marginal log-likelihood")
plot.plot(clf.scores_, color="navy", linewidth=lw)
plot.ylabel("Score")
plot.xlabel("Iterations")
def f(x, noise_amount):
y = np.sqrt(x) * np.sin(x)
noise = np.random.normal(0, 1, len(x))
return y + noise_amount * noise
degree = 10
X = np.linspace(0, 10, 100)
y = f(X, noise_amount=0.1)
clf_poly = BayesianRidge()
clf_poly.fit(np.vander(X, degree), y)
X_plot = np.linspace(0, 11, 25)
y_plot = f(X_plot, noise_amount=0)
y_mean, y_std = clf_poly.predict(np.vander(X_plot, degree), return_std=True)
plot.figure(figsize=(6, 5))
plot.errorbar(
X_plot,
y_mean,
y_std,
color="navy",
label="Polynomial Bayesian Ridge Regression",
linewidth=lw,
)
plot.plot(X_plot, y_plot, color="yellow", linewidth=lw, label="Ground Truth")
plot.ylabel("Output y")
plot.xlabel("Feature X")
plot.legend(loc="lower left")
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到贝叶斯岭回归被绘制在屏幕上。
scikit learn Bayesian ridge regression
您可能还想阅读 scikit learn 上的以下教程。
因此，在本教程中，我们讨论了sci kit learn ridge regression,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习岭回归
- Scikit 学习岭回归系数
- Scikit 学习核岭回归
- Scikit 学习贝叶斯岭回归
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习情绪分析
原文：https://pythonguides.com/scikit-learn-sentiment-analysis/
在这个 Python 教程中，我们将学习Scikit learn 情绪分析如何在 Python 中工作，我们将涵盖与情绪分析相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习情绪分析
- Scikit 学习情绪分类
- Scikit 学习情绪逻辑回归
目录
Scikit 学习情绪分析
本节我们将学习如何 Scikit 学习python 中的情感分析作品。
- 情感分析被定义为自然语言处理的过程和最重要的部分。
- 因为文本数据不能被算法处理。
- 当文本数据被转换成数字数据时，它可以被算法直接处理。
代码:
在下面的代码中，我们将导入一些库，从中我们可以进行情感分析。
data = PD . read _ CSV(" test . CSV ")用于读取测试文件。data.head()用于打印数据集的前五行。
import pandas as pds
import numpy as num
import matplotlib.pyplot as plot
import seaborn as sb
from sklearn.feature_extraction.text import CountVectorizer
count=CountVectorizer()
data=pd.read_csv("Test.csv")
data.head()
运行上面的代码后，我们得到了下面的输出，其中我们可以看到数据集的前五行。
scikit learn sentiment analysis count vectorizer
data.shape 函数用于打印数据集的形状。
data.shape
scikit learn sentiment dataset shape
- fig=plt.figure(figsize=(5，5)) 是在屏幕上绘制图形。
- clrs=["green "，' red'] 用来给图形颜色。
- positive = data[data[' label ']= = 1]用于给图形加正标签。
- 负数=data[data['label']==0] 用于给图形加负数标签。
- piechart=plot.pie(cv，labels=["Positive "，" Negative"]，autopct ='%1.1f%% '，shadow = True，colors = clrs，startangle = 45，explode=(0，0.1)) 用于在绿色上绘制饼图。
- dataframe=[“你好，主人，不要把世界扛在你的肩上，因为你知道，通过使他的世界变得更冷来装酷的人是傻瓜。
bag view = count . fit _ transform(data frame)用于将文本数据转换为数值数据。print(count . get _ feature _ names())用于在屏幕上打印特征名称。
fig=plt.figure(figsize=(5,5))
clrs=["green",'red']
positive=data[data['label']==1]
negative=data[data['label']==0]
cv=[positive['label'].count(),negative['label'].count()]
piechart=plot.pie(cv,labels=["Positive","Negative"],
autopct ='%1.1f%%',
shadow = True,
colors = clrs,
startangle = 45,
explode=(0, 0.1))
dataframe=["Hello master, Dont carry the world upon your shoulders for well you know that its a fool who plays it cool by making his world a little colder Na-na-na,a, na"]
bagview=count.fit_transform(dataframe)
print(count.get_feature_names())
print(bagview.toarray())
运行上面的代码后，我们得到了下面的输出，可以看到文本数据被转换成了数字数据。此外，还可以看到屏幕上显示的带有正面数据和负面数据的饼图。
scikit learn sentiment analysis
阅读: Scikit 学习决策树
Scikit 学习情绪分类
在本节中，我们将了解scikit 如何在 python 中学习情感分类。
- Scikit learn 情感分类是一个自动捕捉文本丰硕状态的过程。
- 情感分类分析是自然语言处理中的一个重要领域。
- 它很容易分析，并广泛应用于客户评论。它还可以看到客户可以给出积极的评论或消极的评论。
代码:
在下面的代码中，我们将导入一些库，从中我们可以估计情感分类分析。
- positive _ folder = f ' { folder }/pos '用于获取正面评论。
- negative _ folder = f { folder }/neg '用于获取负面评论。
return:用于输入文件夹中所有文件的列表。- fld: 用作正面或负面评论文件夹。
- 转正文件=获取转正文件(转正文件夹)用于获取转正审核文件夹。
- 负面 _ 文件=获取 _ 文件(负面 _ 文件夹)用于获取负面评论文件夹。
- *textfile = list(map(lambda txt:re sub((<br \ s /？> )+'，' '，txt)，text) 用于制动行空格用 break。
- IMDB _ train = create _ data _ frame(' aclImdb/train ')用于导入列车数据帧。
- IMDB _ test = create _ data _ frame(' aclImdb/test ')用于创建测试数据帧。
- 从 joblib 导入转储，load 用于保存和加载 sklearn。
- 从 scipy.sparse 导入 save_npz，load_npz 用于保存和加载稀疏矩阵。
- unigram _ vector izers . fit(IMDB _ train[' text ']。【T1 值)】用于计数单字。
- bigram _ vectorizers = count vectorizer(ngram _ range =(1，2)) 用于对 bigram 进行计数。
x _ train _ bigram _ TF _ IDF = bigram _ TF _ IDF _ transformer . transform(x _ train _ bigram)用于训练 biagran_tf_idf。- classifier.fit(x_train，y_train) 用于拟合分类器。
- print(f“{ title } \ n 训练分数:{round(train_score，2)}；验证分数:{round(valid_score，2)}\n') 用于打印标题。
- train _ and _ show _ scores(x _ train _ unigrams，y_train，' Unigram Counts') 用于显示训练 Unigram 的得分。
- train _ and _ show _ scores(x _ train _ bigram，y_train，' Bigram Counts') 用于显示训练 Bigram 的得分
import pandas as pds
import re
from os import system, listdir
from os.path import isfile, join
from random import shuffle
system('wget "http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz"')
system('tar -xzf "aclImdb_v1.tar.gz"')
def create_data_frame(folder: str) -> pd.DataFrame:
positive_folder = f'{folder}/pos'
negative_folder = f'{folder}/neg'
def get_files(fld: str) -> list:
return [join(fld, f) for f in listdir(fld) if isfile(join(fld, f))]
def append_files_data(data_list: list, files: list, label: int) -> None:
for file_path in files:
with open(file_path, 'r') as f:
text = f.read()
data_list.append((text, label))
positive_files = get_files(positive_folder)
negative_files = get_files(negative_folder)
data_list = []
append_files_data(data_list, positive_files, 1)
append_files_data(data_list, negative_files, 0)
shuffle(data_list)
text, label = tuple(zip(*data_list))
textfile = list(map(lambda txt: re.sub('(<br\s*/?>)+', ' ', txt), text))
return pd.DataFrame({'text': text, 'label': label})
imdb_train = create_data_frame('aclImdb/train')
imdb_test = create_data_frame('aclImdb/test')
system("mkdir 'csv'")
imdb_train.to_csv('csv/imdb_train.csv', index=False)
imdb_test.to_csv('csv/imdb_test.csv', index=False)
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from joblib import dump, load
from scipy.sparse import save_npz, load_npz
system("mkdir 'data_preprocessors'")
system("mkdir 'vectorized_data'")
unigram_v
unigram_vectorizers.fit(imdb_train['text'].values)
dump(unigram_vectorizers, 'data_preprocessors/unigram_vectorizer.joblib')
x_train_unigrams = unigram_vectorizers.transform(imdb_train['text'].values)
save_npz('vectorized_data/X_train_unigram.npz', x_train_unigrams)
**# Unigram Tf-Idf**
unigram_tf_idf_transformer = TfidfTransformer()
unigram_tf_idf_transformer.fit(x_train_unigrams)
dump(unigram_tf_idf_transformer, 'data_preprocessors/unigram_tf_idf_transformer.joblib')
x_train_unigram_tf_idf = unigram_tf_idf_transformer.transform(x_train_unigrams)
save_npz('vectorized_data/x_train_unigram_tf_idf.npz', x_train_unigram_tf_idf) load_npz('vectorized_data/X_train_unigram_tf_idf.npz')
**# Bigram Counts**
bigram_vectorizers = CountVectorizer(ngram_range=(1, 2))
bigram_vectorizers.fit(imdb_train['text'].values)
dump(bigram_vectorizers, 'data_preprocessors/bigram_vectorizers.joblib')
x_train_bigram = bigram_vectorizers.transform(imdb_train['text'].values)
save_npz('vectorized_data/x_train_bigram.npz', x_train_bigram)
**# Bigram Tf-Idf**
bigram_tf_idf_transformer = TfidfTransformer()
bigram_tf_idf_transformer.fit(X_train_bigram)
dump(bigram_tf_idf_transformer, 'data_preprocessors/bigram_tf_idf_transformer.joblib')
x_train_bigram_tf_idf = bigram_tf_idf_transformer.transform(x_train_bigram)
save_npz('vectorized_data/x_train_bigram_tf_idf.npz', x_train_bigram_tf_idf)
from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import train_test_split
from scipy.sparse import csr_matrix
import numpy as num
def train_and_show_scores(x: csr_matrix, y: np.array, title: str) -> None:
x_train, x_valid, y_train, y_valid = train_test_split(
x, y, train_size=0.75, stratify=y
)
classifier = SGDClassifier()
classifier.fit(x_train, y_train)
train_score = classifier.score(x_train, y_train)
valid_score = classifier.score(x_valid, y_valid)
print(f'{title}\nTrain score: {round(train_score, 2)} ; Validation score: {round(valid_score, 2)}\n')
y_train = imdb_train['label'].values
train_and_show_scores(x_train_unigrams, y_train, 'Unigram Counts')
train_and_show_scores(x_train_unigram_tf_idf, y_train, 'Unigram Tf-Idf')
train_and_show_scores(x_train_bigram, y_train, 'Bigram Counts')
train_and_show_scores(x_train_bigram_tf_idf, y_train, 'Bigram Tf-Idf')
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到屏幕上打印了 unigram counts、Unigram Tf-Idf、Bigram counts、Bigram Tf-Idf 的得分。
scikit learn sentiment classification analysis
Scikit 学习情绪逻辑回归
在本节中，我们将了解scikit 如何在 python 中学习情绪逻辑回归工作。
- 情感分析回归提到使用文本等数据来分析对某事物的感觉。
- 如果公众对产品的评价不好，公司可以修改产品，这有助于公司做出决定。
- 他们也可以停止生产那种给差评的产品，以避免损失。
- 它很容易分析并广泛应用于人们的推文，它给出了积极或消极推文的评论。
代码:
在下面的代码中，我们将导入一个计数矢量器来将文本数据转换成数字数据。
data.append(i)用于添加数据。- data labels . append(' positive ')用于添加正面推文标签。
- data labels . append(' negative ')用于添加负面推文标签。
features = vectorizers . fit _ transform(data)用于拟合数据。- x_train，x_test，y_train，y _ test = train _ test _ split(features _ nd，datalabels，train_size=0.80，random_state=1234) 用于将数据集吐槽为训练数据和测试数据。
- log reg _ model = log reg _ model . fit(X = X _ train，y=y_train) 用于将数据拟合到 logistic 回归模型中。
- j = rand.randint(0，len(x_test)-7) 用于随机生成数据。
- print(y_pred[0]) 用于打印预测。
- 打印(数据[索引])。【strip())用于打印屏幕上的数据。
from sklearn.feature_extraction.text import CountVectorizer
data = []
datalabels = []
with open("positive_tweets.txt") as f:
for i in f:
data.append(i)
datalabels.append('positive')
with open("negative_tweets.txt") as f:
for i in f:
data.append(i)
datalabels.append('negative')
vectorizers = CountVectorizer(
analyzer = 'word',
lowercase = False,
)
features = vectorizers.fit_transform(
data
)
features_nd = features.toarray()
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(
features_nd,
datalabels,
train_size=0.80,
random_state=1234)
from sklearn.linear_model import LogisticRegression
logreg_model = LogisticRegression()
logreg_model = logreg_model.fit(X=x_train, y=y_train)
y_pred = logreg_model.predict(x_test)
import random as rand
j = rand.randint(0,len(x_test)-7)
for i in range(j,j+7):
print(y_pred[0])
index = features_nd.tolist().index(x_test[i].tolist())
print(data[index].strip())
运行上面的代码后，我们得到下面的输出，其中我们可以看到所有的负数据和正数据都打印在屏幕上。
Scikit learn sentiment logistic regression
在这段代码中，我们将从 sklearn.metrics 导入 accuracy_score，通过它我们可以预测模型的准确性。
print(accuracy_score(y_test，y_pred)) 用于预测模型的精度。
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, y_pred))
运行上面的代码后，我们得到了下面的输出，其中我们可以看到模型的准确性被打印在屏幕上。
scikit learn sentiment logistic regression accuracy score
您可能还想阅读以下 Scikit 学习教程。
因此，在本教程中，我们学习了 Scikit learn 情绪分析，我们还介绍了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习情绪分析
- Scikit 学习情绪分类
- Scikit 学习情绪逻辑回归
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit 学习分割数据
在这个 Python 教程中，我们将学习Scikit learn Split data 如何在 Python 中工作。我们还将介绍与 Scikit learn 分割数据相关的不同示例。此外，我们将涵盖这些主题。
- Scikit 学习分割数据
- Scikit 学习分离训练测试索引
- Scikit 学习按组划分
- Scikit 学习拆分 K 折叠
- Scikit 学习分割数据策略
- Scikit 学习分割时间序列
- Scikit 学习分离训练测试值
如果您不熟悉 Scikit learn，我们建议您阅读什么是 Python 中的 Scikit Learn。
目录
- Scikit 学习分割数据
- Scikit 学习分割列车测试指数
- Scikit 按组学习拆分
- Scikit 学习分割 k 线折叠
- Scikit 学习分割数据策略
- Scikit 学习分割时间序列
- Scikit 学习分割列车测试值
Scikit 学习分割数据
在本节中，我们将了解Scikit learn 如何在 python 中分割数据。
Scikit learn split data frame 用于将数据拆分为训练和测试数据集 split() 函数用于拆分数据，它调用输入数据进行数据拆分。
代码:
在下面的代码中，我们导入了一些库，从中我们可以将数据帧分成训练和测试数据集。
- x，y = num.arange(10)。reshape((5，2))，range(5) 用于排列数据。
array=()用于定义数组。list(y)用于打印屏幕上的数据列表。- x_train，x_test，y_train，y_test = train_test_split(x，y，test_size=0.33，random_state=42) 用于将数据帧拆分为训练和测试数据集。
- train_test_split(y，shuffle=False) 用于拆分数据。
import numpy as num
from sklearn.model_selection import train_test_split
x, y = num.arange(10).reshape((5, 2)), range(5)
x
array=([[1, 2],
[3, 4],
[5, 6],
[7, 8],
[9, 10]])
list(y)
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=0.33, random_state=42)
x_train
train_test_split(y, shuffle=False)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到数据帧被分成训练和测试数据集。
Scikit learn split data
阅读: Scikit 学习图像处理
Scikit 学习分割列车测试指数
在本节中，我们将了解sci kit 如何学习分割训练测试 intext 在 python 中的工作方式。
Scikit 学习分割列车测试索引用于将列车测试数据分割成列车测试索引，以找到列车测试分割。 split() 函数用于将数据分割成一个列车文本索引。
代码:
在下面的代码中，我们将导入一些库，从中我们可以拆分训练测试索引拆分。
- x = num.array([[2，3]，[4，5]，[6，7]，[8，9]，[4，5]，[6，7]]) 用于创建数组。
- random shuffle = shuffles split(n _ splits = 5，test_size=.25，random_state=0) 用于拆分数据。
- 对于 train_index，randomshuffle.split(x)中的 test _ index:用于将数据集拆分成训练测试索引。
- 打印(" TRAIN:"，train_index，" TEST:"，test_index) 用于打印列车测试指标数据。
import numpy as num
from sklearn.model_selection import ShuffleSplit
x = num.array([[2, 3], [4, 5], [6, 7], [8, 9], [4, 5], [6, 7]])
y = num.array([1, 2, 1, 2, 1, 2])
randomshuffle = ShuffleSplit(n_splits=5, test_size=.25, random_state=0)
randomshuffle.get_n_splits(x)
print(randomshuffle)
for train_index, test_index in randomshuffle.split(x):
print("TRAIN:", train_index, "TEST:", test_index)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到数据分为训练和测试索引两部分。
scikit learn split train test index
阅读: Scikit 学习非线性
Scikit 按组学习拆分
在本节中，我们将了解Scikit learn split by group 如何在 python 中工作。
- Scikit learn split group by 用于分割数据并将数据分组。
- 我们可以使用
train_test_split()函数，从中我们可以将数据分成训练集和测试集。
代码:
在下面的代码中，我们导入了一些库，从中我们可以按组分割数据。
iris = load_iris()用于加载虹膜数据。x = iris.data用于导入 x 的值。- x_train，x_test，y_train，y_test = train_test_split(x，y，test_size = 0.6) 用于将数据拆分为训练和测试数据集。
print(Counter(y_train))用于打印 y 列车组的值。- 打印(Counter(y_test)) 用于打印 y 测试组的数据。
from collections import Counter
import numpy as num
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
x = iris.data
y = iris.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.6)
print(Counter(y_train))
print(Counter(y_test))
输出:
在下面的输出中，我们可以看到 y 训练组数据和 y 测试组数据被打印在屏幕上。
Scikit learn split by group
阅读: Scikit 学习 KNN 教程
Scikit 学习分割 k 线折叠
在这一节中，我们将了解Scikit 如何在 python 中学习 split Kfold 的工作方式。
- Scikit learn split Kfold 用于将数据默认拆分为 K 个连续的折叠，而不会被数据打乱。
- 借助于
train_test_split()方法，数据集被分成两部分训练数据和测试数据。
代码:
在下面的代码中，我们将导入一些库，从中我们可以将数据集分成 K 个连续的折叠。
num.random.seed(1338)用于生成随机数。n_splits = 6用于将数据分割成六部分。- percentiles_classes = [0.1，0.3，0.6] 用于生成分组数据。
- group = num . h stack([[ii] 10 for ii in range(10)])*用于平均分割组。
- 图，axis = plot.subplots() 用于绘制图。
axis.set()用于设置屏幕上的轴。
from sklearn.model_selection import (
TimeSeriesSplit,
KFold,
ShuffleSplit,
StratifiedKFold,
GroupShuffleSplit,
GroupKFold,
StratifiedShuffleSplit,
StratifiedGroupKFold,
)
import numpy as num
import matplotlib.pyplot as plot
from matplotlib.patches import Patch
num.random.seed(1338)
cmap_data = plot.cm.Paired
cmap_cv = plot.cm.coolwarm
n_splits = 6
n_points = 100
x = num.random.randn(100, 10)
percentiles_classes = [0.1, 0.3, 0.6]
y = num.hstack([[ii] * int(100 * perc) for ii, perc in enumerate(percentiles_classes)])
group = num.hstack([[ii] * 10 for ii in range(10)])
def visualizegroup(classes, group, name):
figure, axis = plot.subplots()
axis.scatter(
range(len(group)),
[0.5] * len(group),
c=group,
marker="_",
lw=60,
cmap=cmap_data,
)
axis.scatter(
range(len(group)),
[3.5] * len(group),
c=classes,
marker="_",
lw=60,
cmap=cmap_data,
)
axis.set(
ylim=[-1, 5],
yticks=[0.5, 3.5],
yticklabels=["Data\ngroup", "Data\nclass"],
xlabel="Sample index",
)
visualizegroup(y, group, "no groups")
输出:
在下面的输出中，我们可以看到，默认情况下，数据集被分割成 K 个连续的文件夹，没有任何数据混排。
Scikit learn split K fold
阅读: Scikit 学习情绪分析
Scikit 学习分割数据策略
在本节中，我们将了解Scikit 如何学习 python 中的分割数据策略。
- Scikit learn 拆分数据策略用于将数据集拆分为训练数据和测试数据。
- 训练数据用于将数据拟合到模型中，测试数据用于评估拟合数据。
- 我们可以借助
train_test_split()方法拆分训练和测试数据。
代码:
在下面的代码中，我们将导入一些库，从中我们可以拆分数据策略。
range = num . random . random state(0)用于生成随机数。- y = range . poisson(lam = NP . exp(x[:，5]) / 2) 用于与多个零相关的正整数目标。
- x_train，x_test，y_train，y_test = train_test_split(x，y，random_state=range) 用于将数据拆分为训练和测试数据。
- glm.fit(x_train，y_train) 用于拟合数据。
- 打印(glm.score(x_test，y_test)) 用于打印分数。
- num proc = make _ pipeline(simple imputr(strategy = " median ")，StandardScaler()) 用于从数据集制作管道。
- gbdt _ no _ CST = histgradientsboostingregressor()。fit(x，y) 用于拟合 histgradient boosting 回归模型。
display = plot _ partial _ dependency()用于在图形上绘制数据。- display.axes_[0，0]。plot() 用于在屏幕上显示坐标轴。
import numpy as num
from sklearn.model_selection import train_test_split
from sklearn.linear_model import PoissonRegressor
from sklearn.ensemble import HistGradientBoostingRegressor
nsamples, nfeatures = 1000, 20
range = num.random.RandomState(0)
x = range.randn(nsamples, nfeatures)
y = range.poisson(lam=np.exp(x[:, 5]) / 2)
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=range)
glm = PoissonRegressor()
gbdt = HistGradientBoostingRegressor(loss="poisson", learning_rate=0.01)
glm.fit(x_train, y_train)
gbdt.fit(x_train, y_train)
print(glm.score(x_test, y_test))
print(gbdt.score(x_test, y_test))
from sklearn import set_config
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.compose import make_column_transformer
from sklearn.linear_model import LogisticRegression
set_config(display="diagram")
numproc = make_pipeline(SimpleImputer(strategy="median"), StandardScaler())
catproc = make_pipeline(
SimpleImputer(strategy="constant", fill_value="missing"),
OneHotEncoder(handle_unknown="ignore"),
)
preprocessor = make_column_transformer(
(numproc, ("feat1", "feat3")), (catproc, ("feat0", "feat2"))
)
classifier = make_pipeline(preprocessor, LogisticRegression())
classifier
import scipy
import numpy as num
from sklearn.model_selection import train_test_split
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
from sklearn.metrics import completeness_score
range = num.random.RandomState(0)
x, y = make_blobs(random_state=range)
x = scipy.sparse.csr_matrix(x)
x_train, x_test, _, y_test = train_test_split(x, y, random_state=range)
kmeans = KMeans(algorithm="elkan").fit(x_train)
print(completeness_score(kmeans.predict(x_test), y_test))
import numpy as num
from matplotlib import pyplot as plot
from sklearn.model_selection import train_test_split
from sklearn.inspection import plot_partial_dependence
from sklearn.ensemble import HistGradientBoostingRegressor
nsamples = 500
range = num.random.RandomState(0)
x = range.randn(nsamples, 2)
noise = range.normal(loc=0.0, scale=0.01, size=nsamples)
y = 5 * x[:, 0] + num.sin(10 * num.pi * x[:, 0]) - noise
gbdt_no_cst = HistGradientBoostingRegressor().fit(x, y)
gbdt_cst = HistGradientBoostingRegressor(monotonic_cst=[1, 0]).fit(x, y)
display = plot_partial_dependence(
gbdt_no_cst,
x,
features=[0],
feature_names=["feature 0"],
line_kw={"linewidth": 4, "label": "unconstrained", "color": "tab:red"},
)
plot_partial_dependence(
gbdt_cst,
x,
features=[0],
line_kw={"linewidth": 4, "label": "constrained", "color": "tab:cyan"},
ax=display.axes_,
)
display.axes_[0, 0].plot(
x[:, 0], y, "o", alpha=0.5, zorder=-1, label="samples", color="tab:orange"
)
display.axes_[0, 0].set_ylim(-3, 3)
display.axes_[0, 0].set_xlim(-1, 1)
plot.legend()
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到数据集是用他们的数据策略分割的。
Scikit learn split data strategy
阅读: Scikit 学习梯度下降
Scikit 学习分割时间序列
在这一节中，我们将了解Scikit learn split time series 如何在 python 中工作。
Scikit 学习分割时间序列用于训练和测试数据，以固定的时间间隔分割时间。
代码:
在下面的代码中，我们将导入一些库，从中我们可以拆分时间序列数据。
- 图，axis = plot.subplots(figsize=(14，6)) 用于绘制图。
- average week _ demand = data frame . group by([" weekday "，" hour"])。mean()["count"] 用于统计平均周需求。
average week _ demand . plot(ax = axis)= axis . set()用于在图形上绘制坐标轴。time series _ cv = timeseries split()用于拆分时间序列数据。- X.iloc[test_0] 用于按位置选择数据。
from sklearn.datasets import fetch_openml
bikesharing = fetch_openml("Bike_Sharing_Demand", version=2, as_frame=True)
dataframe = bikesharing.frame
import matplotlib.pyplot as plot
figure, axis = plot.subplots(figsize=(14, 6))
averageweek_demand = dataframe.groupby(["weekday", "hour"]).mean()["count"]
averageweek_demand.plot(ax=axis)
_ = axis.set(
title="Average Bike Demand During the week",
xticks=[i * 24 for i in range(7)],
xticklabels=["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
xlabel="Time of the week",
ylabel="Number of bike rentals",
)
y = dataframe["count"] / dataframe["count"].max()
figure, axis = plot.subplots(figsize=(14, 6))
y.hist(bins=30, ax=axis)
_ = axis.set(
xlabel="Fraction of rented fleet demand",
ylabel="Number of hours",
)
x = dataframe.drop("count", axis="columns")
x
from sklearn.model_selection import TimeSeriesSplit
timeseries_cv = TimeSeriesSplit(
n_splits=7,
gap=48,
max_train_size=10000,
test_size=1000,
)
allsplits = list(timeseries_cv.split(x, y))
train_0, test_0 = allsplits[0]
X.iloc[test_0]
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到数据分割时间序列是在屏幕上完成的。
Scikit learn split time series
阅读: Scikit 学习遗传算法
Scikit 学习分割列车测试值
在本节中，我们将学习Scikit 如何在 python 中学习 slit train test Val 的工作方式。
- Scikit learn 分割训练测试 val 用于将数据集分割为训练和测试数据，并获取训练测试分割数据的值。
- 训练数据用于将数据拟合到模型中，测试数据用于评估拟合数据。
代码:
在下面的代码中，我们将导入一些库，从中我们可以拆分 train test val。
- x_train，x_test，y_train，y _ test
= train _ test _ split(x，y，random_state=0) 用于将数据集拆分成训练测试数据。 - figure，axis = plot.subplots() 用于在图形上绘制图形或坐标轴。
- axis.set_xlabel("有效 Alpha") 用于在图形上绘制 x 标签。
- axis.set_title("总杂质与训练集的有效α")用于在屏幕上绘制标题。
import matplotlib.pyplot as plot
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier
x, y = load_breast_cancer(return_X_y=True)
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)
classifier = DecisionTreeClassifier(random_state=0)
path = classifier.cost_complexity_pruning_path(x_train, y_train)
ccpalphas, impurities = path.ccp_alphas, path.impurities
figure, axis = plot.subplots()
axis.plot(ccpalphas[:-2], impurities[:-2], marker="o", drawstyle="steps-post")
axis.set_xlabel("Effective Alpha")
axis.set_ylabel("Total Impurity Of Leaves")
axis.set_title("Total Impurity vs effective alpha for training set")
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上绘制的图形，还可以得到分割训练测试值。
Scikit learn split train test val
您可能还想阅读以下 Scikit 学习教程。
因此，在本教程中，我们讨论了 Scikit learn Split data ，我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Scikit 学习分割数据
- Scikit 学习分离训练测试索引
- Scikit 学习按组划分
- Scikit 学习拆分 K 折叠
- Scikit 学习分割数据策略
- Scikit 学习分割时间序列
- Scikit 学习分离训练测试值
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scikit-learn 与 tensor flow–详细对比
在本 Python 教程中，我们将了解 scikit-learn vs Tensorflow ，还将涵盖 Python 中与 scikit-learn 和 TensorFlow 相关的不同示例。我们将讨论这些话题。
- scikit-learn 如何工作
- 张量流如何工作
- Scikit-learn Vs Tensorflow
Scikit-learn Vs Tensorflow
目录
- scikit-learn 的工作原理
- 【Tenserflow 如何工作
- Scikit-learn Vs Tensorflow
scikit-learn 的工作原理
在本节中，我们将通过使用 python 中的 scikit-library 来了解 scikit-learn 的工作原理。
- Scikit learn 是一个用户友好的、开源的、免费的 python 库。
- 用户可以自由地使用这个库，这可以简化在 python 中应用编码的任务。
- scikit learn 是用 python 编写，构建在 Scipy、Numpy 和 Matplotlib 之上。它只关注数据建模，而不是加载或操作数据。
scikit 学习的安装
pip install scikit-learn
语法:
from sklearn import datasets
sci kit-learn 示例:
在本例中，我们将了解 scikit 如何学习库工作，以及它如何关注建模数据。
- plt.figure(figsize=(16，16)) 用于在屏幕上绘制图形。
- X，y = make _ blob(n _ samples = n _ samples，random_state=random_state) 发出以生成可以存储二进制数据的 blob。
- y_pred = KMeans(n_clusters=4，random_state=random_state)。fit_predict(X) 用于预测不正确的聚类数。
plt.subplot(224)用于绘制支线剧情。- X_varied，y _ varied = make _ blobs(n _ samples = n _ samples，cluster_std=[1.0，2.5，0.5]，random_state=random_state ) 用于制作不同的方差。
- X _ filtered = NP . v stack((X[y = = 0][:500]，X[y == 1][:100]，X[y = = 2][:10])用于制作大小不均匀的块。
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
plt.figure(figsize=(16, 16))
n_samples = 1800
random_state = 200
X, y = make_blobs(n_samples=n_samples, random_state=random_state)
y_pred = KMeans(n_clusters=4, random_state=random_state).fit_predict(X)
plt.subplot(224)
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.title(" Total incorrect number of blobs")
transformations = [[0.60834550, -0.63667344], [-0.40887720, 0.85253230]]
X_aniso = np.dot(X, transformation)
y_pred = KMeans(n_clusters=5, random_state=random_state).fit_predict(X_aniso)
plt.subplot(222)
plt.scatter(X_aniso[:, 0], X_aniso[:, 1], c=y_pred)
plt.title("Total nnumber of Anisotropicly Distributed Blobs")
X_varied, y_varied = make_blobs(
n_samples=n_samples, cluster_std=[1.0, 2.5, 0.5], random_state=random_state
)
y_pred = KMeans(n_clusters=3, random_state=random_state).fit_predict(X_varied)
plt.subplot(223)
plt.scatter(X_varied[:, 0], X_varied[:, 1], c=y_pred)
plt.title("Total number of Unequal Variance")
X_filtered = np.vstack((X[y == 0][:500], X[y == 1][:100], X[y == 2][:10]))
y_pred = KMeans(n_clusters=3, random_state=random_state).fit_predict(X_filtered)
plt.subplot(224)
plt.scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_pred)
plt.title("Total number of Unevenly Sized Blobs")
plt.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到在 scikit-learn 库的帮助下，不同的 K 均值聚类被绘制在屏幕上。
scikit learn example
另外，检查: Scikit-learn 逻辑回归
【Tenserflow 如何工作
在本节中，我们将通过使用 python 中的 TensorFlow 库来了解 Tensorflow 的工作原理。
- TensorFlow 是一个由 Google 团队设计的库，它使记录者的工作变得更加容易。
- 它可以简单方便地计算出数学表达式。
- Tensorflow 涉及深度学习和机器学习技术的编程支持。
- Tensorflow 可以训练用于手写数字分类的深度神经网络，并创建各种序列模型。
- Tensorflow 具有增强相同内存和数据使用的独特功能。
安装张量流:
pip install tensorflow
导入张量流的语法:
import tensorflow as tf
张量流示例:
在下面的例子中，我们将通过 TensorFlow 了解模型的准确性。
- 正如我们所知，它结合了最优化技术的代数运算，使得任何数学计算都变得容易。
models = TF . keras . models . sequential()用于检查模型的准确性。models.compile()用于模型的编译。- models.fit(x_train，y_train，epochs=8) 用于拟合模型。
- models.evaluate(x_test，y_test) 用于评估整个模型。
import tensorflow as tf
mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 260.0, x_test / 260.0
models = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
models.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
models.fit(x_train, y_train, epochs=8)
models.evaluate(x_test, y_test)
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到，通过 TensorFlow，我们可以更轻松地进行数学计算，并获得准确的数据。
Example of Tensorflow
另外，请阅读: Scikit 学习决策树
Scikit-learn Vs Tensorflow
| Scikit -learn | Tensorflow |
| 1.scikit-learn 用于帮助开发人员进行设计，也用于创建新模型并对其进行基准测试。 | 1.Tensorflow 还用于帮助开发人员进行设计，并用于创建新模型的基准。 |
| 2.scikit-learn 在实践中用于广泛的模型范围。 | 2.神经网络的张量流间接使用。 |
| 3.scikit-learn 将其所有算法用作基本估计器 | 3.Tensorflow appliance 的所有算法都在基类中。 |
| 4.scikit-learn 与 XGBoost 等其他框架相比更加灵活 | 4.张量流是用神经网络优化的。 |
| 5.scikit-learn 没有实现一个准系统神经网络模型 | 5.Tensorflow 实现了一个准系统神经网络模型。 |
| 6.scikit-learn 是一个实现机器学习算法的高级库。 | 6.Tensorflow 是一个低级库，它也实现了机器级算法。 |
| 7.scikit-learn 有助于比较完全不同类型的机器学习模型。 | 7.它使其特殊化的引擎盖下优化，这使得比较张量流和神经网络模型更容易。 |
| 8.Scikit-learn 主要用于机器学习 | 8.TensorFlow 主要用于深度学习。 |
| 9.Scikit-learn 是第三方模块，但不如 TensorFlow 受欢迎。 | 9.它也是第三方模块，但更受欢迎。 |
scikit-learn Vs Tensorflow
此外，您可能喜欢:
因此，在本教程中，我们讨论了 scikit-learn Vs Tensorflow ，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- scikit-learn 如何工作
- 张量流如何工作
- Scikit-learn Vs Tensorflow
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Scipy 置信区间[9 个有用的例子]
在本 Python 教程中，我们将学习“ Python Scipy 置信区间”，以及与其使用相关的某些示例。此外，我们将讨论以下主题。
- Python Scipy 置信区间
- Python Scipy 置信区间 T 检验
- Python Scipy 置信区间均值
- Python Scipy 置信区间比例
- Python Scipy 置信区间 T 分布
- Python 科学置信区间二项式
- Python Scipy 置信区间线性回归
- Python Scipy 置信区间差
- Python Scipy 置信区间示例
目录
- Python Scipy 置信区间
- Python Scipy 置信区间 T 检验
- Python Scipy 置信区间均值
- Python Scipy 置信区间比例
- Python Scipy 置信区间二项式
- Python Scipy 置信区间 T 分布
- Python Scipy 置信区间线性回归
- Python Scipy 置信区间差
- Python Scipy 置信区间样本
Python Scipy 置信区间
一个置信区间 (CI)是一组被期望包含一个具有高度确定性的总体值的值。当总体均值落在两个区间之间时，通常用百分比表示。
抽样过程中不确定性或确定性的程度由置信区间来衡量。他们可以使用任意数量的置信度，95%或 99%的置信度是最普遍的。t 检验等统计工具用于计算置信区间。
例如，研究人员可以从同一总体中随机选择不同的样本，并计算每个样本的置信区间，以确定它在多大程度上代表了总体变量的真实值。出现的数据集都是唯一的，一些区间包含真实的总体参数，而另一些不包含。
但是“95%或者 99%的置信区间意味着什么？”95%或 99%置信区间是一组数字，在这个区间内你可能有 95%或 99%的把握，真实的总体均值是包含在内的。
如果多次使用抽样技术，大约 95%的区间可以获得真实的总体平均值。
Python Scipy 置信区间 T 检验
t 检验是比较两组平均值的统计检验。它经常被用于假设检验，以观察一种方法或治疗是否对感兴趣的人群有影响，或者两个群体是否彼此不同。
Python Scipy 有四种不同的方法*ttest_1samp()*、*ttest_ind()*、*ttest_ind_from_stats()*和*ttest_rel()*。
ttest_1samp():计算一组分数平均值的 T 检验。ttest_ind():计算两个独立分数样本的 T 检验。ttest_ind_from_stats():来自描述统计学，对两个独立样本的均值进行 T 检验。ttest_rel():计算两个相关分数样本 a 和 b 的 t 检验。
这里我们将学习唯一的方法*ttest_1samp()*，要了解其余方法，请访问 Python SciPY 的官网。
下面给出了该方法的语法。
scipy.stats.ttest_1samp(a,axis=0, popmean, nan_policy='propagate', alternative='one-sided')
其中参数为:
- a(数组 _ 数据): 观察样本。
- 轴(int): 测试将沿此轴计算；默认值为 0。如果没有，则对整个数组 a 执行计算。
- 【pop mean():在零假设下，这是期望值。如果是 array_data，它应该有精确的形状，减去轴的维度。
- 备择: 备择假设在此定义。有多种选择，如双面、较小和较大。
- nan_policy: 当输入包含 nan 时，该属性指定如何处理。有几个选项可用，默认为“propagate”:
- ' propagate ':这是一个返回 nan 的选项。
- ' raise ':它会导致引发错误。
- '省略':它在执行计算时忽略 nan 值。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库或方法。
import numpy as np
from scipy.stats import ttest_1samp
首先，我们将使用下面的代码创建一个数组来保存 12 个工厂的测量值。
samp_data = [11, 11, 13, 10, 9, 14, 12, 11, 12, 10, 12, 11]
使用方法 ttest_1samp() 执行单样本测试，如以下代码所示。
ttest_1samp(a=samp_data, popmean=14)
Python Scipy Confidence Interval T-Test
t 检验统计量的双侧 p 值为 3.2025，t 检验统计量为 6.7393。
对于这个单样本 t 检验，以下是两个假设:
- H0(无效假设):这种植物的平均高度是 14 英寸
- H1(另一个假设):平均身高不是 14 英寸。( ≠14)
这里 p 值大于 0.5，所以我们拒绝零假设，接受备择假设。
阅读: Python Scipy FFT
Python Scipy 置信区间均值
均值的置信区间是一组值，在特定的置信水平下，这些值可能包括总体均值。
置信区间的公式如下所示。
Confidence interval
其中参数为:
x̅: 代表样本均值。
t: 置信度对应的 t 值。
s: 样本的标准差。
n: 样本数。
如果我们有一个小样本，比如少于 30 个，我们可以使用*scipy.stats* Python 库的*t.interval()*函数构建一个总体均值的置信区间。
让我们通过下面的步骤来了解一个示例:
使用下面的 python 代码导入所需的库。
from scipy import stats
import numpy as np
使用下面的代码创建示例数据。
samp_data = [15, 15, 15, 15, 14, 17, 18, 21, 22, 24, 26, 29, 29, 30, 25]
使用下面的代码创建 99%的置信区间。
stats.t.interval(alpha=0.95, loc=np.mean(samp_data), df=len(samp_data)-1, scale=stats.sem(samp_data))
Python Scipy Confidence Interval Mean
真实总体均值的 95%置信区间为(17.764，24.235)。
Python Scipy 置信区间比例
Python Scipy 在模块*scipy.stats._result_classes*中包含了一个方法*BinomTestResult.proportion_ci()*,用于确定估计比例的置信区间。
下面给出了语法。
BinomTestResult.proportion_ci(confidence_level=0.99, method='wilson')
其中参数为:
- confidence_level(float): 估计比例的计算置信区间的置信水平。默认值为 0.95。
- 方法:选择计算比例估计置信区间的方法:
- “精确”:应该使用 Clopper-Pearson 精确方法。
- '威尔逊':威尔逊的方法没有连续性校正被称为'威尔逊'
- 威尔逊的技术包括连续性校正。
方法*BinomTestResult.proportion_ci()*返回 ci(置信区间的上下界存储在对象的高低属性中) 。
Python Scipy 置信区间二项式
二项式分布是一种概率分布，表示在给定一组因素或假设的情况下，某个值取两个独立值之一的可能性。在本节中，我们将使用二项式分布来计算置信区间。
Python Scipy 模块*scipy.stats*包含一个方法*binom.interval()*，使用这个方法我们将计算 CI。让我们按照以下步骤来看一个例子:
使用下面的 python 代码导入所需的库。
from scipy import stats
import numpy as np
使用下面的代码创建示例数据。
samp_data = [2,5,3,7,9,5,7,2,6,7]
使用下面的代码计算置信区间。
stats.binom.interval(alpha=0.99,
n=len(samp_data)-1,
loc=np.mean(samp_data),
p=stats.sem(samp_data))
Python Scipy Confidence Interval Binomial
这就是如何计算二项分布的置信区间。
阅读: Scipy 正态分布
Python Scipy 置信区间 T 分布
当总体标准差未知且数据来自正态分布总体时，t 分布表征样本均值和总体均值之间的归一化距离。
- 换句话说，t 分布也称为学生 t 分布，是一组类似于正态分布曲线但略短且略粗的分布。
- 当样本很少时，使用 t 分布，而不是正态分布。t 分布更像正态分布，更像样本量的增加。
- 实际上，对于大于 20 的样本量，该分布几乎与正态分布相同。
下面是正态和 t 分布形状的给定图片。
Scipy Confidence Interval T Distribution
我们已经做过与 t 分布相关的例子，请参考本教程的“Python Scipy 置信区间均值” 小节。
Python Scipy 置信区间线性回归
Python Scipy 模块*scipy.stats*包含一个方法*linregress()*，该方法用于两组测量，以执行线性最小二乘回归。这里我们将计算两个变量 x 和 y 之间的线性回归，然后求出所计算的线性回归的斜率和截距的置信区间。
下面给出了语法。
scipy.stats.linregress(x, y=None, alternative='less')
其中参数为:
- x，y(array_data): 有两个测量集。两个数组的长度应该相同。如果只指定了 x(并且 y=None)，则数组必须是二维的，其中一个维度的长度为 2。
- 备择:备择假设在这里定义。有多种选择，如双面、较小和较大。
方法*linregress()*返回类型 float 的*slope*、*intercept*、*rvalue*、*pvalue*、*stderr*和*intercept_err*。
让我们按照以下步骤通过一个示例来理解:
使用下面的 python 代码导入所需的库。
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import linregress, t
使用下面的代码创建一个随机数生成器并生成 x 和 y 数据。
rand_numgen = np.random.default_rng()
x_data =rand_numgen.random(15)
y_data = 1.5*x_data + rand_numgen.random(15)
使用下面的代码计算线性回归。
lin_res = linregress(x_data, y_data)
使用下面的代码打印斜率和截距。
print("Slope",lin_res.slope)
print("Intercept",lin_res.intercept)
使用下面的代码将数据和拟合线一起绘制在图表上。
plt.plot(x_data, y_data, 'o', label='original data')
plt.plot(x_data, lin_res.intercept + lin_res.slope*x_data, 'r', label='fitted line')
plt.legend()
plt.show()
Python Scipy Confidence Interval Linear Regression
使用以下代码计算斜率和截距的 95%置信区间。
t_inv = lambda prob, degree_of_freedom: abs(t.ppf(prob/2, degree_of_freedom))
使用下面的代码打印斜率和截距的置信区间。
Python Scipy 置信区间差
假设我们有来自配对实验的两组数据，它们并不相互独立，我们希望为两个样本之间的平均差异建立一个置信区间。计算置信区间的程序是什么？假设我们决定置信水平为 0.05。
使用下面的 python 代码导入所需的库。
from scipy import stats
import numpy as np
使用下面的代码指定由 alpha 表示的 95%的置信度。
alp = 0.05
使用下面的代码创建两个样本数据。
samp_data1 = np.array([14, 17, 10, 19, 7, 20])
samp_data2 = np.array([ 3, 2, 10, 16, 10, 8])
使用下面的代码计算一个样本和每个样本中的观察值之间的差异。
diffsamp = samp_data1 - samp_data2
len_no_obs = len(samp_data1)
此外，使用以下代码计算 CI 的均值和方差、临界值和半径。
diffmean = np.mean(diffsamp)
diffvar = np.var( diffsamp, ddof=1 )
criticalvalue = stats.t.ppf(q = 1-alp/2, df = len_no_obs - 1)
rad = criticalvalue*np.sqrt(diffvar)/np.sqrt(len_no_obs)
现在使用下面的代码计算置信区间差。
print(diffmean - rad, diffmean + rad)
Python Scipy Confidence Interval Difference
这就是求置信区间差的方法。
阅读: Scipy 信号-有用教程
Python Scipy 置信区间样本
在本节中，我们将创建一个函数，它将根据给定的样本数据计算置信区间。
让我们按照下面的步骤来创建一个方法或函数。
使用下面的 python 代码导入所需的库。
from scipy import stats
import numpy as np
使用下面的代码创建一个函数来计算给定数据样本的置信区间。
def m_conf_intval(samp_data, confid=0.95):
data = 1.0 * np.array(samp_data)
len_n = len(data)
mean, std_err = np.mean(data), stats.sem(data)
h = std_err * stats.t.ppf((1 + confid) / 2., len_n-1)
return mean, mean-h, mean+h
现在，使用下面的代码向上面创建的方法提供样本数据。
data = [2,4,6,3,8,9,4]
m_conf_intval(data)
Python Scipy Confidence Interval Sample
看输出，置信区间的范围是 2.729 到 7.556。
在上面的代码中，我们创建了一个方法*m_conf_intval()*来计算给定数据或样本的置信区间。
另外，看看更多的 Python SciPy 教程。
- Scipy Convolve–完整指南
- 如何使用 Python Scipy Linprog
- Python Scipy 特征值
- Scipy Stats–完整指南
- Scipy 优化–实用指南
- Python Scipy 距离矩阵
因此，在本教程中，我们已经了解了" Python Scipy 置信区间"并涵盖了以下主题。
- Python Scipy 置信区间
- Python Scipy 置信区间 T 检验
- Python Scipy 置信区间均值
- Python Scipy 置信区间比例
- Python Scipy 置信区间 T 分布
- Python 科学置信区间二项式
- Python Scipy 置信区间线性回归
- Python Scipy 置信区间差
- Python Scipy 置信区间示例
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scipy 常量–多个示例
在这个 Python 教程中，我们将学习“ Scipy 常量，在这里我们将了解 Scipy 中不同类型的常量。此外，涵盖以下主题。
- 科学常数 Python
- Scipy 常量单位
- Scipy 常量列表
- 科学常数 C
- 科学常数ε0
- Scipy 常量查找
- 科学常数 hbar
- Scipy Constants mu0
- 光速常数
- 科学常数里德伯
- 科学常数温度
目录
- 科学常数 Python
- Scipy 常量单位
- Scipy 常量列表
- 科学常数 C
- 科学常数ε0
- Scipy 常量查找
- 科学常数 hbar
- 科学常数 mu0
- 光速常数
- 科学常数里德堡
- Scipy 常数温度
科学常数 Python
Scipy Constants 是一个 Python 子包，包含许多不同类型的科学领域常数。这些常数可以根据我们在数据科学、深度学习、机器学习中的需要来使用。
Scipy 中有三种类型的常量:
- 物理常数:物理常数有真空中的光速(
c)、磁常数(mu_0)等。 - 数学常数:数学常数有圆周率(
pi)、黄金分割率(golden) 、(golden_ratio)。 - 单位:单位有
*Mass*、*Time*、*Angle*等。
在后面的小节中，我们将分别学习每个常数。
这里我们将使用 Jupyter 笔记本来演示如何导入和使用 Scipy 常量。
打开 Jupyter Notebook，在单元格中键入以下代码以导入 Scipy 常量。
import scipy.constants as constant
Scipy Constants Python
让我们检查一些 Scipy 常量的值。
使用以下代码检查数学常数Pi的值。
print(constant.pi)
使用以下代码检查物理常数speed of light的值。
print(constant.speed_of_light)
使用以下代码检查 Uni gram的值。
print(constant.gram)
Scipy Constant
另外，检查:Python 中的 Scikit 是学什么的
Scipy 常量单位
在这里，我们将了解 Scipy 单元，Scipy 中有 15 种类型的单元，每种类型都包含其常数。
下面给出了 Scipy 中的单位类型。
- 角
- 团
- SI 前缀
- 二进制前缀
- 时间
- 长度
- 压力
- 卷
- 速度
- 面积
- 温度
- 活力
- 力量
- 光学
- 力
角度
角度单位有degree*arcmin*``*arcminute*``*arcsec*``*arcsecond*等常量。这些常数的单位值是弧度。
运行下面的代码来查看 Angle 中所有常量的值。
print('The value of degree in radians :',const.degree)
print('The value of arc minute in radians :',const.arcmin)
print('The value of arc minute in radians :',const.arcminute)
print('The value of arc second in radians :',const.arcsec)
print('The value of arc second in radians :',const.arcsecond)
Scipy Constants Units Angle
质量
质量单位有*gram*、*metric*、*grain*等常量。它以千克为单位返回单位值。下面用代码显示了所有的常数。
运行下面的代码来查看所有联系人的值。
print('The value of gram is equal to 10 to the power -3 in kg :',const.gram)
print('The value of gram is equal to 10 to the power 3 in kg :',const.metric_ton)
print('The value of one grain in kg :',const.grain)
print('The value of one pound in kg :',const.lb)
print('The value of one pound in kg :',const.pound)
print('The value of one ounce in kg :',const.oz)
print('The value of one ounce in kg :',const.ounce)
print('The value of one stone in kg :',const.stone)
print('The value of one slug in kg :',const.slug)
print('The value of one long ton in kg :',const.long_ton)
print('The value of one short ton in kg :',const.short_ton)
print('The value of one inch version of a slug in kg :',const.slinch)
print('The value of one inch version of a slug in kg :',const.blob)
print('The value of one troy ounce in kg :',const.troy_ounce)
print('The value of one troy pound in kg :',const.troy_pound)
print('The value of one carat in kg :',const.carat)
print('The value of one atomic mass constant in kg :',const.atomic_mass)
print('The value of one atomic mass constant in kg :',const.m_u)
print('The value of one atomic mass constant in kg :',const.u)
Scipy Constants Units Mass
读取 Scipy 优化
SI 前缀
SI 前缀单位有*Zetta*、*Yotta*、*Peta*等常量。它以米为单位返回单位值。下面用代码显示了所有的常数。
print('The value of yotta is equal to 10 to the power 24 :',const.yotta)
print('The value of zetta is equal to 10 to the power 21 :',const.zetta)
print('The value of exa is equal to 10 to the power 18 :',const.exa)
print('The value of peta is equal to 10 to the power 15 :',const.peta)
print('The value of tera is equal to 10 to the power 12 :',const.tera)
print('The value of giga is equal to 10 to the power 9 :',const.giga)
print('The value of mega is equal to 10 to the power 6 :',const.mega)
print('The value of kilo is equal to 10 to the power 3 :',const.kilo)
print('The value of hecto is equal to 10 to the power 2 :',const.hecto)
print('The value of deka is equal to 10 to the power 1 :',const.deka)
print('The value of deci is equal to 10 to the power -1 :',const.deci)
print('The value of centi is equal to 10 to the power -2 :',const.centi)
print('The value of milli is equal to 10 to the power -3 :',const.milli)
print('The value of micro is equal to 10 to the power -6 :',const.micro)
print('The value of nano is equal to 10 to the power -9 :',const.nano)
print('The value of pico is equal to 10 to the power -12 :',const.pico)
print('The value of femto is equal to 10 to the power -15 :',const.femto)
print('The value of atto is equal to 10 to the power -18 :',const.atto)
print('The value of zepto is equal to 10 to the power -21 :',const.zepto)
print('The value of yocto is equal to 10 to the power -24 :',const.yocto)
Scipy Constants Units SI prefixes
二进制前缀
二进制前缀单元有*gibi*、*pebi*、*mebi*等常量。它以字节为单位返回单位值。下面用代码显示了所有的常数。
print('The value of kibi is equal to 2 to the power 10 :',const.kibi)
print('The value of kibi is equal to 2 to the power 20 :',const.mebi)
print('The value of kibi is equal to 2 to the power 30 :',const.gibi)
print('The value of kibi is equal to 2 to the power 40 :',const.tebi)
print('The value of kibi is equal to 2 to the power 50 :',const.pebi)
print('The value of kibi is equal to 2 to the power 60 :',const.exbi)
print('The value of kibi is equal to 2 to the power 70 :',const.zebi)
print('The value of kibi is equal to 2 to the power 80 :',const.yobi)
Scipy Constants Units Binary prefixes
时间
时间单位有*minute*、*day*、*hour*等常量。它以秒为单位返回单位值。下面用代码显示了所有的常数。
print('The value of one minute in seconds :',const.minute)
print('The value of one hour in seconds :',const.hour)
print('The value of one day in seconds :',const.day)
print('The value of one week in seconds :',const.week)
print('The value of one year in seconds :',const.year)
print('The value of one Julian_year in seconds :',const.Julian_year)
Scipy Constants Units Time
长度
长度单位有常量，如*foot*、*mile*、*fermi*等。它返回以米为单位的单位值。下面用代码显示了所有的常数。
print('The value of one inch in meters :',const.inch)
print('The value of one foot in meters :',const.foot)
print('The value of one yard in meters :',const.yard)
print('The value of one mile in meters :',const.mile)
print('The value of one mil in meters :',const.mil)
print('The value of one pt in meters :',const.pt)
print('The value of one point in meters :',const.point)
print('The value of one survey foot in meters :',const.survey_foot)
print('The value of one survey mile in meters :',const.survey_mile)
print('The value of one nautical mile in meters :',const.nautical_mile)
print('The value of one fermi in meters :',const.fermi)
print('The value of one angstrom in meters :',const.angstrom)
print('The value of one micron in meters :',const.micron)
print('The value of one astronomical unit in meters :',const.au)
print('The value of one astronomical unit in meters :',const.astronomical_unit)
print('The value of one light year in meters :',const.light_year)
print('The value of one parsec in meters :',const.parsec)
Scipy Constants Units Length
压力
压力单位有*psi*、*atm*、*bar*等常量。它返回以帕斯卡为单位的单位值。下面用代码显示了所有的常数。
print('The value of standard atomsphere in pascals :',const.atm)
print('The value of standard atomsphere in pascals :',const.atmosphere)
print('The value of one bar in pascals :',const.bar)
print('The value of one torr in pascals :',const.torr)
print('The value of one torr in pascals :',const.mmHg)
print('The value of one psi in pascals :',const.psi)
Scipy Constants Units Pressure
体积
体积单位有常数如*gallon*、*litre*、*barrel*等。它以立方米为单位返回单位值。下面用代码显示了所有的常数。
print('The value of one litre in cubic meters :',const.liter)
print('The value of one litre in cubic meters :',const.litre)
print('The value of one gallon (United States) in cubic meters :',const.gallon)
print('The value of one gallon (United States) in cubic meters :',const.gallon_US)
print('The value of one gallon (United Kingdom) in cubic meters :',const.gallon_imp)
print('The value of one fluid ounce (United States) in cubic meters :',const.fluid_ounce)
print('The value of one fluid ounce (United States) in cubic meters :',const.fluid_ounce_US)
print('The value of one fluid ounce (United Kindom) in cubic meters :',const.fluid_ounce_imp)
print('The value of one barrel in cubic meters :',const.barrel)
print('The value of one barrel in cubic meters :',const.bbl)
Scipy Constants Units Volume
速度
速度单位有*mph*、*mach*、*knot*等常量。它以米/秒为单位返回单位值。下面用代码显示了所有的常数。
print('The value of kmh kilometers per hour in meters per second :',const.kmh)
print('The value of mph miles per hour in meters per second :',const.mph)
print('The value of one mach meters per second :',const.mach)
print('The value of one mach meters per second :',const.speed_of_sound)
print('The value of one knot meters per second :',const.knot)
Scipy Constants Units Speed
区域
面积单位有像公顷、英亩这样的常数。它以平方米为单位返回单位值。下面用代码显示了所有的常数。
print('The value of one hectare in square meters :',const.hectare)
print('The value of one acre in square meters :',const.acre)
Scipy Constants Units Area
温度
温度单位有零摄氏度、华氏度等常量。它返回开尔文单位值。下面用代码显示了所有的常数。
print('The value of zero of celsius scale in Kelvin :',const.zero_Celsius)
print('The value of zero of fahrenheit scale in Kelvin :',const.degree_Fahrenheit)
Scipy Constants Units Temperature
能量
能量单位有 eV、卡路里等常量。它以焦耳为单位返回单位值。下面用代码显示了所有的常数。
print('The value of one electron volt in Joules :',const.eV)
print('The value of one electron volt in Joules :',const.electron_volt)
print('The value of one calorie (Thermochemical) in Joules :',const.calorie)
print('The value of one calorie (Thermochemical) in Joules :',const.calorie_th)
print('The value of one calorie (International steam table calorie)in Joules :',const.calorie_IT)
print('The value of one erg in Joules :',const.erg)
print('The value of one british thermal unit in Joules :',const.Btu)
print('The value of one british thermal unit (International steam table) in Joules :',const.Btu_IT)
print('The value of one british thermal unit (International steam table) in Joules :',const.Btu_th)
print('The value of one ton of TNT in Joules :',const.ton_TNT)
Scipy Constants Units Energy
功率
功率单位有常量，如 hp，马力。它以瓦特为单位返回单位值。下面用代码显示了所有的常数。
print('The value of one horsepower in watts :',const.hp)
print('The value of one horsepower in watts :',const.horsepower)
Scipy Constants Units Power
光学
光学单元具有返回光学频率的常数*lambda2nu( )*和返回波长的常数*nu2lambda( )*。
力
力的单位有*kgf*、*dyn*等常量。它以牛顿为单位返回单位值。下面用代码显示了所有的常数。
print('The value of one dyne in newtons :',const.dyn)
print('The value of one dyne in newtons :',const.dyne)
print('The value of one pound force in newtons :',const.lbf)
print('The value of one pound force in newtons :',const.pound_force)
print('The value of one kilogram force in newtons :',const.kgf)
print('The value of one kilogram force in newtons :',const.kilogram_force)
Scipy Constants Units Force
Scipy 常量列表
要查看或列出 Scipy 中的所有常数，为此我们将使用函数 dir( ) ，我们将从 Scipy 导入的常数传递给该函数来查看所有常数。
这里我们将使用下面的代码导入 Scipy 子包常量。
import scipy.constants as const
现在将上面导入的子包传递给函数*dir( )*。
print(dir(const))
在上面的代码函数*dir( )*中，接受子包名称*const*并显示该包中的所有常量，如下面的输出所示。
Scipy Constants list
科学常数 C
在 Scipy 中，常数*c* 代表真空中的光速，是一个物理常数。
要导入这些常量，请遵循以下步骤:
import scipy.constants as cons
检查真空中光速不变的值。
print('The value of speed of light in vacuum :',cons.c)
在这里，我们可以使用*cons.c*来访问常量。
Scipy Constants C
用常数*c*表示的真空中光速的值是 299792458.0 。
科学常数ε0
在 Scipy 中，*epsilon 0*是存在于*scipy.constants*内的电常数。
要导入这些常量，请遵循以下步骤:
import scipy.constants as cons
使用以下代码检查电常数的值。
print('The value of the electric constant :',cons.epsilon_0)
在这里，我们可以使用*cons.epsilon_0*来访问常量。
Scipy Constants epsilon 0
Scipy 常量查找
为了获得 Scipy 中物理常数的密钥，使用了*scipy.constants*的方法*find( )*。
下面给出了语法。
scipy.constants.find(sub_str=None, disp=False)
其中参数为:
- sub_str: 它是子串或者是我们要搜索其关键字的物理常量的名称。
- dips: 如果设置为
True则返回找到的键，否则不显示任何内容列出所有键。
让我们用下面的代码来举例说明如何导入和列出物理常数的键。
from scipy.constants import find, physical_constants
检查包含字典***'avogadro'***的物理常数中的键。
find('avogadro')
使用以下代码列出常数***'Avogadro constant'***。
physical_constants['Avogadro constant']
Scipy Constants find
阅读:Scipy Stats Zscore+Examples
科学常数 hbar
在 Scipy 中，常数*hbar*是普朗克常数的修改形式，存在于值等于*h= h/2pi)*的*scipy.constants*内。
要导入这些常量，请遵循以下步骤:
import scipy.constants as cons
使用下面的代码检查普朗克常数的值。
print('The value of Plancs constant :',cons.hbar)
Scipy Constants hbar
科学常数 mu0
在 Scipy 中，*mu_0*是存在于*scipy.constants*内的磁常数。
要导入这些常量，请遵循以下步骤:
import scipy.constants as cons
使用以下代码检查磁常数的值。
print('The value of the magnetic constant :',cons.mu_0)
在这里，我们可以访问常数*cons.mu_0*。
Scipy Constants mu0
光速常数
在 Scipy 中，常数*speed_of_ligh*代表真空中的光速，是一个物理常数。
要导入这些常量，请遵循以下步骤:
import scipy.constants as cons
检查真空中光速不变的值。
print('The value of speed of light in vacuum :',cons.c)
Scipy Constants speed of light
科学常数里德堡
在 Scipy 中，常数*Rydberg*是里德伯常数，是物理常数。
要导入这些常量，请遵循以下步骤:
import scipy.constants as cons
检查里德伯常数的值。
print('The value of Rydberg constant :',cons.Rydberg)
Scipy Constants Rydberg
阅读: Python Scipy 指数
Scipy 温度常数
温度单位有*zero_Celsius*、*degree_Fahrenheit*等常量。它返回开尔文单位值。下面用代码显示了所有的常数。
print('The value of zero of celsius scale in Kelvin :',const.zero_Celsius)
print('The value of zero of fahrenheit scale in Kelvin :',const.degree_Fahrenheit)
Scipy Constants Units Temperature
看看上面输出中两个常量的值。
还有，多看看一些教程。
在本教程中，我们学习了" Scipy 常量"并涵盖了以下主题。
- 科学常数 Python
- Scipy 常量单位
- Scipy 常量列表
- 科学常数 C
- 科学常数ε0
- Scipy 常量查找
- 科学常数 hbar
- Scipy Constants mu0
- 光速常数
- 科学常数里德伯
- 科学常数温度
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
scipy Convolve–完整指南
在这个 Python 教程中，我们将学习“ Scipy Convolve ”，此外，我们还将使用一些例子讨论以下主题。
- Scipy 卷积 3d
- 科学卷积 2d
- Scipy 卷积 1d
- 快速卷积 fft
- 高斯卷积
- 敏捷的回旋步伐
- 沿轴卷曲
- 卷曲核
目录
Scipy 卷积 1d
Scipy 在模块*scipy.ndimage*中有一个方法*convolve1d()*,它使用提供的权重计算指定轴上的一维卷积。
下面给出了语法。
scipy.ndimage.convolve1d(input, weights, axis=- 1, output=None, mode='reflect', cval=0.1, origin=1)
其中参数为:
- 输入(数组): 输入的是数组数据。
- 权重(ndarray): 它是一维的数列。
- axis(int): 该参数表示给定数组中要计算卷积的轴。
- output(dtype，array): 用于指定作为输出返回的数组的数据类型。
- mode(): 当我们想要扩展输入数组的边界时，它用来控制输入数组的边界。模式有
*wrap*、*constant*、*nearest*、*mirror*和*reflect*。 - cval(标量): 当模式设置为
constant时，用于填充输入数组过去的边。 - origin(int): 用于将过滤器放在给定的输入数组上，如果值为零则将过滤器放在中间。如果值为正，将滤镜放在左侧，如果值为负，将滤镜放在右侧。
让我们通过下面的步骤来了解一个示例:
使用下面的 python 代码导入所需的库。
from scipy import ndimage
使用下面的 Python 代码创建一个包含多个值和权重的数组。
a = [4,6,3,5,6,0,9]
w = [2,6]
现在将上面创建的数组和权重传递给方法*convolve1d*。
ndimage.convolve1d(a,weights=w)
Scipy Convolve 1d
阅读: Scipy 优化–实用指南
Scipy 卷积器 2d
Scipy 在模块*scipy.ndimage*中有一个方法*convolve()*，它使用提供的权重计算指定轴上的多维卷积。
下面给出了语法。
scipy.ndimage.convolve(input, weights, axis=- 1, output=None, mode='reflect', cval=0.1, origin=1)
其中参数为:
- 输入(数组): 输入的是数组数据。
- 权重(ndarray): 权重数组的维数必须等于输入数组的维数。
- output(dtype，array): 用于指定作为输出返回的数组的数据类型。
- mode(): 当我们想要扩展输入数组的边界时，它用来控制输入数组的边界。这些模式包括环绕、恒定、最近、镜像和反射。
- cval(标量):当模式设置为常量时，它用于填充输入数组的过去的边。
- origin(int):用于在给定的输入数组上放置过滤器，如果值为零，则将过滤器放在中间。如果值为正，将滤镜放在左侧，如果值为负，将滤镜放在右侧。
让我们通过下面的步骤来了解一个示例:
使用下面的 python 代码导入所需的库。
from scipy import ndimage
import numpy as np
使用下面的 Python 代码创建一个包含多个值和权重的二维数组。
array_data = np.array([(5,4,6,8),(1,0,7,4)])
weight = np.array([[0,0,1],[1,1,1]])
现在将上面创建的二维数组和权重传递给方法*convolve*。
ndimage.convolve(array_data,weights=weight,cval=0.1,mode='constant')
Scipy Convolve 2d
阅读:剪切旋转图像
Scipy 卷积 3d
Scipy 在模块*scipy.ndimage*中有一个方法*convolve()*，用于计算多维卷积。这里，我们将使用与上一小节中使用的 3d 数组相同的方法。
下面给出了语法。
scipy.ndimage.convolve(input, weights, axis=- 1, output=None, mode='reflect', cval=0.1, origin=1)
其中参数为:
- 输入(数组): 输入的是数组数据。
- 权重(ndarray): 权重数组的维数必须等于输入数组的维数。
- output(dtype，array): 用于指定作为输出返回的数组的数据类型。
- mode(): 当我们想要扩展输入数组的边界时，它用来控制输入数组的边界。这些模式包括环绕、恒定、最近、镜像和反射。
- cval(标量): 用于在模式设置为常量时填充输入数组的过去的边。
- origin(int): 用于将过滤器放在给定的输入数组上，如果值为零则将过滤器放在中间。如果值为正，将滤镜放在左侧，如果值为负，将滤镜放在右侧。
让我们通过下面的步骤来了解一个示例:
使用下面的 python 代码导入所需的库。
from scipy import ndimage
import numpy as np
使用下面的代码创建一个包含多个值和权重的三维数组。
array_data = np.array([[[3,18], [46, 80]], [[0, 0], [62, 86]],[[86,34],[22,19]]])
weight = np.array([[[0,0,1],[1,1,1],[0,1,0]]])
现在将上面创建的三维数组和权重传递给方法*convolve*。
ndimage.convolve(array_data,weights=weight,cval=0.1,mode='constant')
Scipy Convolve 3d
阅读:科学常数
Scipy 卷积 fft
Scipy 在模块*scipy.signal*中有一个方法*fftconvolve()*，它使用方法 FFT (快速傅立叶变换)卷积 n 维数组。
下面给出了语法。
scipy.signal.fftconvolve(in1, in2, mode='full', method='auto')
其中参数为:
- in1(array_data): 用于以数组的形式输入第一个信号。
- in2(array_data): 用于以数组的形式输入第二个信号，维数必须与第一个输入数组相同。
- 模式: 用于指定决定输出大小的字符串。模式可以是
*same*、*full*和*valid*。 - 方法: 用于指定计算卷积的方法。方法可以是
*auto*、*direct*、*fft*。
让我们通过下面的步骤来了解一个示例:
使用下面的 python 代码导入所需的库。
from scipy.signal import fftconvolve
import scipy.signal
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
生成随机噪声信号，并使用以下代码应用方法fftconvolveI()。
random_gen = np.random.default_rng()
s = random_gen.standard_normal(800)
autocorrelation = fftconvolve(s, s[::-1], mode='full')
让我们用下面的代码画出上面卷积的信号。
fig, (orig_axes, mag_axes) = plt.subplots(2, 1)
orig_axes.plot(s)
orig_axes.set_title('It is noise')
mag_axes.plot(np.arange(-len(s)+1,len(s)), autocorrelation)
mag_axes.set_title('It is autocorrelation')
fig.tight_layout()
fig.show()
Scipy Convolve fftconvolve
这是如何在 Python 中使用 Scipy 来使用方法*fftconvolve()*。
阅读:科学统计
Scipy 卷积高斯
Scipy 在模块*scipy.ndimage*中有一个方法*gaussian_filter*，它将高斯函数应用到多维数组中。
下面给出了语法。
scipy.ndimage.gaussian_filter(input, sigma, order=0, output=int, mode='nerest', cval=1.1, truncate=3.1)
其中参数为:
- 输入(数组 _ 数据): 输入的是数组数据。
- ∑(标量序列): 高斯核标准差。
- 顺序(int): 用于指定过滤器的顺序。
- output(dtype，array): 用于指定作为输出返回的数组的数据类型。
- mode(): 当我们想要扩展给定数组的边界时，它用来控制作为输入的该数组的边界。模式有
*wrap*、*constant*、*nearest*、*mirror*和*reflect*。 - cval(标量): 用于当模式设置为
constant时，填充给定数组过去的边作为输入。
方法*gaussian_filter*返回 ndarray 类型的 gaussian_filter 。
让我们通过下面的步骤用一个例子来理解:
使用下面的 python 代码导入所需的库。
from scipy.ndimage import gaussian_filter
import numpy as np
使用下面的代码创建一个包含值的数组。
array_data = np.arange(100, step=4).reshape((5,5))
array_data
现在，使用下面的代码对数组数据应用高斯过滤器。
gaussian_filter(array_data, sigma=1)
Scipy Convolve Gaussian
这是如何在 Python 程序中使用 Scipy 将高斯过滤器应用于数据数组。
Scipy 沿轴卷积
这里我们将使用 Scipy 的相同方法*convolve1d()*在指定的轴上卷积给定的数组。
要了解方法*convolve()*，请参考上述小节。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy import ndimage
import numpy as np
使用下面的 python 代码创建一个包含多个值和权重的二维数组。
array_data = np.array([(4,5,8,6),(0,1,4,7)])
weight = [0,1,1]
将上面创建的二维数组和权重传递给方法*convolve*，不指定轴参数。
ndimage.convolve1d(array_data,weights=weight)
使用下面的代码，在轴等于 0 的情况下再次运行上面的代码。
ndimage.convolve1d(array_data,weights=weight,axis=0)
Scipy Convolve along axis
看看两个代码的结果，一个没有轴，另一个有轴。
阅读: Scipy 信号-有用教程
Scipy 卷积内核
权重是卷积中称为核的一组值，它作为输入在给定的数组上滑动以转换该数据。这里我们将使用我们在上面小节中学到的相同的 Scipy 方法*convolve()*。
让我们按照以下步骤通过一个示例来理解:
使用下面的 python 代码导入所需的库。
from scipy import ndimage
import numpy as np
使用下面的代码创建一个包含几个值和权重或内核的二维数组。
array_data = np.array([(1,4,8,6),(4,7,0,4)])
kernel = np.array([[1,0,1],[1,1,0]])
将上面创建的二维数组和内核传递给方法*convolve*并查看结果。
ndimage.convolve(array_data,weights=kernel)
使用下面的代码创建一个新的内核。
kernel_2 = np.array([[0,0,1],[0,1,1]])
同样，将新内核传递给一个方法，并使用下面的代码查看结果。
ndimage.convolve(array_data,weights=kernel_2)
Scipy Convolve kernel
这就是如何使用不同的内核对相同的数据实现不同的转换。
另外，请查看以下 Python SciPy 教程。
- Python Scipy Freqz
- Scipy Integrate +示例
- Python Scipy 距离矩阵
- Scipy Linalg–实用指南
- Scipy Ndimage Rotate
- Python Scipy Matrix +示例
- Scipy Stats Zscore +示例
因此，在本教程中，我们学习了“ Scipy Convolve ”并涵盖了以下主题。
- Scipy 卷积 3d
- 科学卷积 2d
- Scipy 卷积 1d
- 快速卷积 fft
- 高斯卷积
- 敏捷的回旋步伐
- 沿轴卷曲
- 卷曲核
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 Python Scipy 差分进化
我们将学习“ Python Scipy 差分进化 ”，差分进化(DE)是一种基于种群的元启发式搜索技术，它基于进化过程迭代地改进潜在的解决方案，以优化问题。还将介绍如何使用不同的策略并行计算解决方案，主题如下。
- 什么是差异进化
- Python 科学差分进化
- 如何使用不同策略的科学差分进化
- 如何并行执行快速差分进化
- 定义约束并在差异进化中使用它们
- Python Scipy 差分进化界限
目录
- 什么是差异进化
- Python Scipy 差分进化
- Python Scipy 差分进化策略
- Python Scipy 差分进化并行
- Python Scipy 差分进化约束
- Python Scipy 差分进化界限
什么是差异进化
差分进化(DE)，一种用于进化计算的技术，寻求迭代地增强关于指定质量度量的候选解。
由于它们可以搜索很宽的潜在解空间，并且对被优化的问题很少或不做假设，这种技术经常被称为元启发式。然而，像 DE 这样的元试探法并不能确保找到理想的解决方案。
不同于传统的优化技术，如梯度下降和拟牛顿法，它们都要求优化问题是可微的，DE 不使用被优化问题的梯度，因此适用于多维实值函数。因此，差分进化可以应用于优化问题，甚至不连续，噪音，随时间变化等。
DE 使用简单的公式来组合当前的候选解，以创建新的候选解，维持候选解的群体，并保留手头的优化任务上具有最高分数或适应度的候选解。
在这种方法中，不需要梯度，因为优化问题被视为“黑箱”,它只提供给定候选解的质量度量。
- 潜在解决方案的群体是差分进化算法的基本变体的运行方式(称为代理)。通过组合群体中当前代理的位置，这些代理使用简单的数学公式在搜索空间中移动。
- 如果一个代理的新位置是一个改进，它被接受并添加到群体中；否则就是刚淘汰。人们希望，但不能保证，重复这一程序将导致最终发现一个可行的解决办法。
Python Scipy 差分进化
模块scipy.optimize有一个方法differential_evolution(),可以找到多元函数的全局最小值。
下面给出了语法。
scipy.optimize.differential_evolution(func, bounds, strategy='best1bin', maxiter=1000, popsize=15, tol=0.01, mutation=(0.5, 1), recombination=0.7, seed=None, callback=None, disp=False, polish=True, init='latinhypercube', atol=0, updating='immediate', workers=1, constraints=(), x0=None, *, integrality=None, vectorized=False)
其中参数为:
-
func(可调用):目标是最小化目标函数。必须具有 f(x，*args)的形式，其中 args 是完整解释函数所需的所有附加固定参数的元组，x 是一维数组形式的输入。n 就参数(x)而言等于 len。
-
界限(序列):对于变量，界限。可以用两种方法之一来指定边界:1 .Bounds 类实例。2.(min，max)对，为 x 中的每个元素指定 func 的优化参数的有限下限和上限。参数的数量 N 通过边界的总和计算得出。
-
策略(字符串):使用差异进化的技术。应该是下列值之一:“best1bin”、“best1exp”、“rand1exp”、“randtobest1exp”、“currenttobest1exp”、“best2exp”、“rand2exp”、“randtobest1bin”、“currenttobest1bin”、“best2bin”、“rand2bin”、“rand1bin”。
-
maxiter(int): 整个种群最多可以进化的代数。(maxiter + 1) * popsize * N 是可以执行的函数求值的最大次数(没有抛光)。
-
popsize(int): 用于确定人口总体规模的乘数。人口中有 popsize * N 人。如果 init 关键字用于提供初始填充，则忽略该术语。当使用 init='sobol '时，通过在 popsize * N 之后取 2 的下一次幂来确定群体大小。
-
tol(float): 当求解器达到收敛的相对容差时，NP . STD(pop)= atol+tol * NP . ABS(NP . mean(群体能量))，其中，atol 和 tol 是对应的绝对容差和相对容差。
-
突变(浮点或元组):诱变常数。术语“不同重量”也在文献中使用，用字母 f 表示。如果提供浮子，应使用范围[0，2]。当值以元组(min，max)的形式给出时，使用抖动。在逐代的基础上，抖动随机修改变异常数。对于世代，U[min，max]用于计算变异常数。抖动可以大大加速收敛。虽然增加变异常数会减慢收敛速度，但会扩大搜索范围。
-
重组(浮点):范围[0，1]应该是重组常数。这在文献中也称为交叉概率，用字母 CR 表示。增加这个值允许更多的突变体存活到下一代，但是这样做是以牺牲种群稳定性为代价的。
-
seed: 如果 seed 为 None(或 np.random)则使用 Numpy.random。它使用 RandomState 的单例。如果种子是整数，则创建 RandomState 的一个新实例，并用该种子作为种子。如果种子已经有一个生成器或 RandomState 实例，则使用它。对于重复最小化，请指定一个种子。
-
disp(bool): 在每次迭代时，打印计算后的函数。
-
回调:跟踪最小化过程的函数。目前为止最好的答案是 xk。val 表示总体收敛的分数值。当 val 大于 1 时，该功能停止。当回调返回 True 时，最小化停止(任何抛光仍在进行)。
-
polish(boolean): 如果为真(默认)，则在最后使用 L-BFGS-B 方法对最佳群体成员进行抛光，这可以略微增强最小化。当研究一个有限的问题时，信任-建构方法被用来代替它。
-
init(string，array_data): 表示执行的群体初始化的种类。应该是以下之一:“latinhypercube”、“sobol”、“halton”、“random”。
-
atol(float): 当达到收敛的绝对容差 NP . STD(pop)= atol+tol * NP . ABS(NP . mean(群体能量))时，其中 atol 和 tol 是对应的绝对和相对容差，问题无法解决。
-
更新(延迟，立即):如果“立即”，则最优解向量在整个一代中重复更新。结果，收敛可能发生得更快，因为试验向量可能受益于理想结果的持续发展。当选择该选项时，最佳解决方案向量每一代更新一次。与并行化或矢量化兼容的唯一选项是“延迟”，它可以被 workers 和矢量化关键字覆盖。
-
workers(int 或 map-like):如果 workers 是一个整数，则群体被分成 workers 部分并并行计算(使用多重处理)。池)。要利用所有的 CPU 内核，请提供-1。或者，提供一个类似于映射的可调用函数，比如多重处理。Pool.map 用于同时评估总体。该评估由工人(func，iterable)完成。如果工人！= 1，此选项将用 updating='deferred '替换 updating 关键字。如果工人！= 1，此选项优先于矢量化关键字。它还要求 func 是可选择的。
-
约束(bounds，LinearConstraint，NonLinearConstraint):除了边界 kwd 所施加的限制之外，对求解器的附加限制。采用了兰皮宁的策略。
-
x0(array_like 或 None):在开始时给出最小化的粗略估计。一旦群体被初始化，这个向量就代替初始(最佳)成员。即使给 init 一个初始种群，这种替换仍然会执行。Shape == x0 (N，)。
-
integrality(一维数组):一个布尔值，指示决策变量是否限于每个决策变量的整数值。该阵列传输到(N，)。如果任何决策变量需要积分，抛光过程不会改变它们。我们只利用落在上限和下限内的整数。如果边界之间没有整数值，将引发 ValueError。
-
矢量化(布尔值):给定一个 x 数组，x.shape == (N，S)，func 应该返回一个包含 shape 的数组，其中 S 是需要生成的解向量的数量，如果矢量化设置为 True。如果使用了约束，每个构建约束对象的函数都应该接受一个 x 数组，其中 x.shape == (N，S)并返回一个 shape (M，S)数组，其中 M 是约束组件的数量。工作者并行化的这种替代方案可以通过最小化来自重复函数调用的解释器开销来提高优化速度。如果工人！= 1，将不使用该关键字。updating='deferred '选项将优先于 updating 关键字。有关何时使用“矢量化”和何时使用“workers”的更多信息，请参见注释部分。
方法differential_evolution()返回res:optimize result 对象用于表示优化结果。解决方案数组 x、success、指示优化器是否成功终止的布尔指示以及解释终止原因的消息都是重要的特性。
让我们举个例子，了解一下方法differential_evolution()是如何工作的。
使用下面的 python 代码导入所需的库或方法。
from scipy import optimize
考虑 Rosenbrock 函数最小化问题。在“scipy.optimize”中，这个函数是使用下面的代码在 Rosen 中实现的。
bounds_ = [(0,1), (0, 1), (0, 1), (0, 1), (0, 1)]
result_ = optimize.differential_evolution(optimize.rosen, bounds_)
result_.x, result_.fun
Python Scipy Differential Evolution
这就是如何使用 Python Scipy 的方法*differential_evolution()*对目标函数rsoen执行差分进化。
阅读: Python Scipy Lognormal + 10 个例子
Python Scipy 差分进化策略
该算法特别适合于非微分非线性目标函数，因为它在搜索过程中不使用梯度信息。
该方法通过跟踪被表示为具有实值的向量的潜在答案群体来操作。当前解决方案的修改版本用于产生新的候选解决方案，每次算法迭代时，这些新的候选解决方案替换相当大的群体块。
使用 “策略” ，形成新的候选解，所述策略包括选择向其引入突变的基础解和来自群体的额外候选解，从所述群体中确定突变的数量和种类，称为差异向量。例如，对于变异中的差异向量，策略可能选择最佳候选解作为基础和随机解。
使用以下常用术语描述差异策略:
“DE/x/y/z”:其中 DE 指的是“差异进化”，x 表示将被改变的初始解。例如，“rand”代表随机，“best”代表在群体中找到的最佳解决方案。变量 y 和 z 用于表示添加到基础解的差向量的数量，例如 1，概率分布用于决定每个解在总体中是被保留还是被替换，例如分别为二项式或指数式。
由于配置“DE/best/1/bin”和“DE/best/2/bin”在广泛的目标函数上的强大性能，它们是很受欢迎的配置。
【策略】 参数是 Python Scipy 方法*differential_evolution*的一个至关重要的超参数，它规定了所执行的差分进化搜索的种类。这通常设置为【best 1 bin】(DE/best/1/bin)，这是一个适合大多数问题的设置。通过从群体中选择随机解决方案，将它们彼此相除，并将结果的缩放版本添加到群体中的顶部候选解决方案，它生成新的候选解决方案。
阅读: Python Scipy Butterworth 滤镜
Python Scipy 差分进化并行
该函数将并行最小化，因此要了解差分进化并行是如何工作的，请参考上面小节中解释的参数updating和workers。
让我们以与上述小节相同的示例为例，但按照以下步骤进行并行化:
使用下面的 python 代码导入所需的库或方法。
from scipy import optimize
使用下面的代码考虑 Rosenbrock 函数最小化问题。
bounds_ = [(1,3), (1, 3), (1, 3), (1, 3), (1, 3)]
result_ = optimize.differential_evolution(optimize.rosen, bounds_,updating='deferred',workers=2)
result_.x, result_.fun
Python Scipy Differential Evolution Parallel
这就是如何使用 Python Scipy 的方法*differential_evolution()*和参数*workers*来执行并行差分进化。
Python Scipy 差分进化约束
我们已经了解了如何计算差异进化及其参数，因此在本节中，我们将按照以下步骤进行约束最小化:
使用下面的 python 代码导入所需的库或方法。
from scipy import optimize
import numpy as np
使用下面的代码定义约束函数。
def constr_fun(x):
return np.array(x[0] + x[1])
使用下面的代码，使用方法*NonLinearConstraint*和*Bounds*定义约束和界限或限制。
nlc_ = optimize.NonlinearConstraint(constr_fun, -np.inf, 1.8)
bounds_ = optimize.Bounds([0., 0.], [1., 2.])
现在使用下面的代码最小化约束。
result = optimize.differential_evolution(optimize.rosen, bounds_, constraints=(nlc_),
seed=1)
result.x, result.fun
Python Scipy Differential Evolution Constraints
这就是如何通过 Python Scipy 的方法*differential_evolution()*使用约束。
Python Scipy 差分进化界限
Python Scipy 的方法*differential_evolution()*接受一个参数*bounds*。有两种方法来定义边界:1 .界限类实例号。2.对于 x 中的每个元素，使用(min，max)对来提供 func 的优化参数的有限下限和上限。边界总数用于计算参数计数 n。
让我们以上面小节中使用的相同示例为例，通过以下步骤来理解参数界限是如何工作的:
使用下面的 python 代码导入所需的库或方法。
from scipy import optimize
import numpy as np
使用下面的代码定义约束函数。
def constr_fun(x):
return np.array(x[0] + x[1])
使用下面的代码，使用方法*NonLinearConstraint*和*Bounds*定义约束和界限或限制。
nlc_ = optimize.NonlinearConstraint(constr_fun, -np.inf, 1.8)
bounds_ = optimize.Bounds([0., 0.], [1., 2.])
在上面的代码中界限被定义为Bounds([0., 0.], [1., 2.])。
现在使用下面的代码最小化约束。
result = optimize.differential_evolution(optimize.rosen, bounds_, constraints=(nlc_),
seed=1)
result.x, result.fun
现在，使用下面的代码更改界限的值。
nlc_ = optimize.NonlinearConstraint(constr_fun, -np.inf, 1.8)
bounds_ = optimize.Bounds([2., 0.], [1., 2.])
使用下面的代码计算不同边界的最小化约束。
result = optimize.differential_evolution(optimize.rosen, bounds_, constraints=(nlc_),
seed=1)
result.x, result.fun
Python Scipy Differential Evolution Bounds
这就是如何定义边界并在*differential_evolution()* Python Scipy 中使用它们。
您可能也喜欢阅读下面的 Python Scipy 教程。
- Python Scipy Gamma
- Python Scipy 平滑
- Python Scipy Softmax
- Python Scipy 统计数据偏差
- Python Scipy Kdtree
- Python Scipy 统计模式
我们已经学习了如何使用差分进化找到最优解，并并行执行差分进化以使过程更快，还学习了如何使用差分进化的约束和界限。
- 什么是差异进化
- Python 科学差分进化
- 如何使用不同策略的科学差分进化
- 如何并行执行快速差分进化
- 定义约束并在差异进化中使用它们
- Python Scipy 差分进化界限
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 科学距离矩阵
在本 Python 教程中，我们将学习“ Python Scipy 距离矩阵”，其中我们将使用不同的距离方法(如欧几里德、曼哈顿等)计算矩阵或数组之间的距离，并涵盖以下主题。
- Python 科学距离矩阵
- Python 科学距离矩阵 Cdist
- Python Scipy 距离矩阵 Pdist
- Python 科学距离矩阵欧几里得
- Python Scipy 距离矩阵城市街区
- Python Scipy 距离矩阵聚类
- Python Scipy 距离矩阵定向 Hausdorff
- Python Scipy 距离矩阵余弦
- Python 科学距离相关矩阵
另外，查看 Python SciPy 的最新教程: Python Scipy Stats Kurtosis
目录
- Python Scipy 距离矩阵
- Python Scipy 距离矩阵 Cdist
- Python 科学距离矩阵 Pdist
- Python Scipy 距离矩阵欧几里德
- Python Scipy 距离矩阵 Cityblock
- Python Scipy 距离矩阵聚类
- Python Scipy 距离矩阵定向 Hausdorff
- Python Scipy 距离矩阵余弦
- Python Scipy 距离相关矩阵
Python Scipy 距离矩阵
成对计算的矩阵向量之间的距离包含在距离矩阵中。我们可以使用由*scipy.spatial*模块提供的*distance_matrix()*方法来计算距离矩阵。在大多数情况下，矩阵具有二维数组的形状，矩阵行充当矩阵的向量(一维数组)。
下面给出了语法。
scipy.spatial.distance_matrix(x, y, threshold=1000000, p=2)
其中参数为:
- x(array_data(m，k): 有 M 个向量的 K 维矩阵。
- y(array_data(n，k)): N 乘向量的 K 维矩阵。
- threshold(positive int): 如果 M * N * K 大于阈值，则该算法使用 Python 循环而不是大型临时数组。
- p(float): 应该应用哪个闵可夫斯基 p 范数。
方法*distance_matrix()*返回一个矩阵，该矩阵测量 x 中的每个向量和 y 中的每个 ndarray 类型的向量之间的间距。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy import spatial
import numpy as np
使用下面的代码创建矩阵。
x_mat = np.array([[2,3],[1,2],[3,3]])
y_mat = np.array([[1,2],[2,0],[5,0]])
使用下面的代码计算距离矩阵。
d_matrix = spatial.distance_matrix(x_mat,y_mat,p=2)
使用下面的代码查看距离矩阵。
print(d_matrix)
Python Scipy Distance Matrix
这就是如何使用模块 Python *scipy.spatial*的方法*distance_matrix()*计算距离矩阵。
也可阅读: Python Scipy 指数
Python Scipy 距离矩阵 Cdist
Python Scipy 在模块*scipy.spatial.distance*中包含了一个方法*cdist()*，该方法计算两个输入集合之间的距离。
下面给出了语法。
scipy.spatial.distance.cdist(XA, XB, metric='cosine')
其中参数为:
- XA(array _ data):n 维中的原始 m [B] 观察值的数组，每个测量 m [B] 乘 n
- XB(array _ data):n 维中的原始 m [B] 观察值的数组，每个测量 m [B] 乘 n
- metric(callabel，str): 要应用的距离单位。距离函数可以是"堪培拉"、"布雷柯蒂斯"、"切比雪夫"、"相关"、"城市街区"、"余弦"、"欧几里得"、"骰子"、"汉明"、"库尔辛斯基"、"简森山农"、"库尔辛斯基"、"匹配"、"马哈拉诺比斯"、"明科夫斯基"、"罗素劳"、"罗格斯坦本"、"修克列迪安"。
方法 cdist() 返回的结果是大小为 m [A] 乘 m [B] 的距离矩阵。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.spatial.distance import cdist
使用下面的代码创建数据。
coord_data = [(25.056, -75.7226),
(25.7411, -79.1197),
(25.2897, -79.2294),
(25.6716, -79.3378)]
在四个二维坐标之间，计算它们的欧几里得距离。
cdist(coord_data,coord_data,'euclidean')
Python Scipy Distance Matrix Cdist
这就是如何使用 Python Scipy 的方法*cdist()*来计算两个输入集合的每一对之间的距离。
Python 科学距离矩阵 Pdist
Python Scipy 在模块*scipy.spatial.distance*中包含一个方法*pdist()*,用于计算 n 维空间中观测值之间的成对距离。
下面给出了语法。
scipy.spatial.distance.pdist(X, metric='minkowski)
其中参数为:
- X(array _ data):n 维中 m 个唯一观测值的数组，m 乘 n 排列。
- metric(callabel，str): 要应用的距离单位。距离函数可以是"堪培拉"、"布雷柯蒂斯"、"切比雪夫"、"相关"、"城市街区"、"余弦"、"欧几里得"、"骰子"、"汉明"、"库尔辛斯基"、"简森山农"、"库尔辛斯基"、"匹配"、"马哈拉诺比斯"、"明科夫斯基"、"罗素劳"、"罗格斯坦本"、"修克列迪安"。
方法pdist()返回 ndarray 类型的 Y(这是压缩的距离矩阵 Y) 。
让我们按照以下步骤，通过插图来理解:
使用下面的 python 代码导入所需的库。
from scipy.spatial.distance import pdist
使用下面的代码创建数据。
data = [(25.056, -75.7226),
(25.7411, -79.1197),
(25.2897, -79.2294),
(25.6716, -79.3378)]
使用欧几里德距离(2-范数)作为点之间的距离度量来计算 m 点之间的距离。在矩阵数据中，点被排列成 m 个 n 维行向量。
pdist(data,'euclidean')
该指南使用 Python Scipy 的*pdist()*计算 n 维空间中观测值之间的成对距离
阅读: Scipy 寻找峰值–有用教程
Python Scipy 距离矩阵欧几里德
Python Scipy 在模块*scipy.spatial.distance*中包含了一个方法*euclidean()*，用于计算两个一维数组之间的欧几里德距离。
下面给出了语法。
scipy.spatial.distance.euclidean(u, v, w=None)
其中参数为:
- u(array_data): 输入矩阵或数组。
- v(array_data): 输入矩阵或数组。
- w(array_data): 每个值在 u 和 v 中的权重，当默认选择无时，每个值的权重为 1。
方法*euclidean()*返回 double 类型的 euclidean(这是两个向量 u 和 v 的欧几里德距离) 。
让我们按照下面的步骤做一些例子:
导入方法*euclidean()*并使用下面的 python 代码计算距离。
from scipy.spatial.distance import euclidean
euclidean([2, 1, 0], [1, 1, 2])
Python Scipy Distance Matrix Euclidean
看上面的输出，给定数组的欧氏距离是 2.236。
这就是如何使用 Python Scipy 的方法*euclidean()*计算欧几里德距离。
阅读: Python Scipy 特辑
Python Scipy 距离矩阵 Cityblock
Python Scipy 模块*scipy.spatial.distance*包含一个计算曼哈顿距离(也称为城市街区距离)的方法*cityblock()*。
下面给出了语法。
scipy.spatial.distance.cityblock(u, v, w=None)
其中参数为:
- u(array_data): 输入矩阵或数组。
- v(array_data): 输入矩阵或数组。
- w(array_data): 每个值在 u 和 v 中的权重，默认选择无时，每个值的权重为 1。
方法*cityblokc()*返回 double 类型的 (这是两个向量 u 和 v 的曼哈顿(cityblock)距离) 。
让我们按照下面的步骤做一些例子:
导入方法*cityblok()*并使用下面的 python 代码计算曼哈顿的距离。
from scipy.spatial.distance import cityblock
cityblock([1, 0, 2], [2, 1, 2])
Python Scipy Distance Matrix Cityblock
看看上面的输出，给定数组的 cityblock(曼哈顿)距离是 2。
这就是如何使用 Python Scipy 的方法*cityblock()*计算城市街区距离。
Python Scipy 距离矩阵聚类
Python Scipy 模块*scipy.spatial.hierarchy*包含一个方法*linkage()*,该方法使用分层或凝聚方法对数据进行聚类。但是 “什么是层次聚类？”
- 一种称为分层聚类的算法，通常被称为分层聚类分析，根据对象的相似程度将对象划分为多个聚类。结果是一个集群的集合，每个集群都不同于其他集群，但都有大体相似的东西。
Python Scipy Distance Matrix Clustering
下面给出了语法。
scipy.cluster.hierarchy.linkage(y, method='complete', optimal_ordering=False, metric='euclidean')
其中参数为:
- y(ndarray): 一个压缩的距离矩阵。距离矩阵的上部三角形包含在称为压缩距离矩阵的平面阵列中。Pdist 返回这个表单作为结果。一个 m 乘 n 的数组也可以用来传递一组 n 维的 m 个观察向量。在压缩距离矩阵中不能有任何 nan 或 INF，所有元素必须是有限的。
- 方法(str，function): 要使用的适当的联动算法。
- optimal _ ordering(boolean):如果为真，连接矩阵将被重新排列，以使后续叶之间的距离尽可能短。当数据被可视化时，这导致了更容易理解的树结构。默认为 False，因为该算法可能会降低性能，尤其是对于大型数据集。
- 度量(str): 如果 y 是观测向量的集合，那么使用这个距离度量；否则，忽略它。有关可接受的距离测量列表，请参考 pdist 功能。此外，还提供自定义距离功能。
方法 linkage() 返回 ndarray 类型的 z(链接矩阵用于对层次分组进行编码) 。
使用下面的 python 代码导入所需的库。
from scipy.cluster.hierarchy import linkage, dendrogram
import matplotlib.pyplot as plt
使用下面的代码创建我们想要执行聚类的数据。
data = [[i] for i in [1, 7, 1, 5, 2, 8, 8, 1]]
将上面创建的数据传递给带有 ward 的方法*linkage()*,使用下面的代码计算聚类。
res = linkage(data, 'ward')
使用下面的代码绘制上述结果的树状图。
fig = plt.figure(figsize=(5, 5))
dendo = dendrogram(res)
在上面的代码中，我们已经将方法***linkage(data,'ward')***的结果传递给方法*dendrogram(res)*来显示获得聚类的树状图。
Python Scipy Distance Matrix Clustering
这就是如何使用 Python Scipy 的方法*linkage()*计算距离矩阵聚类。
阅读:Scipy Stats Zscore+Examples
Python Scipy 距离矩阵定向 Hausdorff
Python Scipy 模块*scipy.spatial.distance*包含一个方法*directed_hausdorff()*,用于查找两个二维数组之间的有向 hausdorff 距离。
下面给出了语法。
scipy.spatial.distance.directed_hausdorff(u, v, seed=2)
其中参数为:
- u(array_data，(M，N)): 输入矩阵或数组。
- v(array_data，(ON)): 输入矩阵或数组。
- seed(int): 默认值 0 通过随机重新排列 u 和 v 的值来确保可重复性。
方法*directed_hausdorff()*分别返回 double、int 和 int 类型的 d(数组 u 和 v 的有向豪斯多夫距离) 、 index_1(构成豪斯多夫对的 u 中的点的索引) 和 index_2(构成豪斯多夫对的 v 中的点的索引) 。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.spatial import distance
import numpy as np
使用下面的代码创建两个二维数组。
u_arr = np.array([(2.0, 0.0),
(0.0, 2.0),
(-2.0, 0.0),
(0.0, -2.0)])
v_arr = np.array([(1.0, 0.0),
(0.0, 1.0),
(-1.0, 0.0),
(0.0, -2.0)])
使用下面的代码计算上面创建的数组的有向豪斯多夫距离。
distance.directed_hausdorff(u_arr, v_arr)[0]
Python Scipy Distance Matrix Directed Hausdorff
看看上面的输出，给定数组之间的有向 Hausdorff 距离是 1。
这就是如何使用 Python Scipy 的方法*directed_hausdorff()*计算有向 Hausdorff 距离。
阅读: Scipy 卷积-完整指南
Python Scipy 距离矩阵余弦
Python Scipy 模块*scipy.spatial.distance*包含一个方法*cosine()*,用于识别一维数组的余弦距离。
假设 u 和 v 的余弦距离为:
Python Scipy Distance Matrix Cosine
下面给出了语法。
scipy.spatial.distance.cosine(u, v, w=None)
其中参数为:
- u(array_data): 输入矩阵或数组。
- v(array_data): 输入矩阵或数组。
- w(array_data): 每个值在 u 和 v 中的权重，当默认选择无时，每个值的权重为 1。
方法*cosine()*返回 double 类型的 cosine(这是 u 和 v 彼此之间的余弦距离) 。
让我们以下面的步骤为例:
导入方法*cosine()*并使用下面的 python 代码计算距离。
from scipy.spatial.distance import cosine
cosine([0, 1, 1], [1, 0, 1])
Python Scipy Distance Matrix Cosine
看上面的输出，给定数组的余弦距离是 0.5。
这就是如何使用 Python Scipy 的方法*cosine()*计算余弦距离。
Python Scipy 距离相关矩阵
Python Scipy 在模块*scipy.spatial.distance*中有一个方法*correlation()*,用于识别两个一维数组中间的相关距离。
假设 u 和 v 的相关距离为:
Python Scipy Distance Correlation Matrix
下面给出了语法。
scipy.spatial.distance.correlation(u, v, w, centered = False)
- u(array_data): 输入矩阵或数组。
- v(array_data): 输入矩阵或数组。
- w(array_data): 每个值在 u 和 v 中的权重，当默认选择无时，每个值的权重为 1。
- 居中(布尔):如果准确，u 和 v 会在中间。默认情况下为 True。
方法*correlation()*返回 double 类型的*correlation*(这是一维数组 u 和 v 在相关性方面的分离)。
让我们以下面的步骤为例:
导入方法*correlation()*并使用下面的 python 代码计算距离。
from scipy.spatial.distance import correlation
correlation([0, 1, 1], [1, 0, 1])
Python Scipy Distance Correlation Matrix
看上面的输出，给定数组的相关距离是 1.5。
这就是如何使用 Python Scipy 的方法*correlation()*计算相关距离。
您可能也喜欢阅读下面的 Python Scipy 教程。
因此，在本教程中，我们已经了解了“Python Scipy 距离矩阵”并涵盖了以下主题。
- Python 科学距离矩阵
- Python 科学距离矩阵 Cdist
- Python Scipy 距离矩阵 Pdist
- Python 科学距离矩阵欧几里得
- Python Scipy 距离矩阵城市街区
- Python Scipy 距离矩阵聚类
- Python Scipy 距离矩阵定向 Hausdorff
- Python Scipy 距离矩阵余弦
- Python 科学距离相关矩阵
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scipy 查找峰值–有用的教程
在这个 Python 教程中，我们将学习“ Scipy Find Peaks ”并借助各种例子讨论它的可用性。此外，涵盖以下主题。
- 科学发现峰值
- 科学发现了突出的顶峰
- Scipy 查找峰值 cwt
- 科学发现高峰和低谷
- 科学发现峰值最小值
- Scipy 发现峰宽
另外，查看最新的 Python Scipy 教程: Python Scipy 曲线拟合
目录
科学发现高峰
Python Scipy 在模块*scipy.signal*中有一个方法*find_peaks()*，它根据给定的峰值属性返回所有的峰值。峰值不仅仅是电信号的峰值，数学函数中的最大值和最小值也被认为是峰值。
下面给出了语法。
scipy.signal.find_peaks(x, height=1, prominence=4, distance=2, width=2, threshold=1, rel_height=0.5, wlen=1, )
其中参数为:
- x(序列): 用于接受需要寻找峰值的信号。
- height (sequence，ndarray，number): 可能是一个整数，也可能是一个数组，用来设置待识别峰的最小高度。
- threshold(sequence，ndarray，number): 一个峰值和它的邻居之间所需的垂直距离被称为阈值，当我们不想从噪声中挑出峰值时，它在噪声函数的情况下是非常有益的。
- 距离(数): 是相邻山峰之间所需的最小水平距离(数)。在峰值周期已知的情况下，这是非常有价值的。
- 日珥(sequence，ndarray，number): 用于提供峰值日珥。
- 宽度(sequence，ndarray，number): 用于提供峰值的宽度。
- wlen(int): 它用于计算日珥峰值。
- rel_height(int): 用于计算峰高。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.signal import find_peaks
from scipy.misc import electrocardiogram
import matplotlib.pyplot as plt
%matplotlib inline
使用以下代码生成心电图。
value = electrocardiogram()[1000:5000]
现在使用下面的代码。
peak, _ = find_peaks(value, height=0)
plt.plot(value)
plt.plot(peak, value[peak], "*")
plt.plot(np.zeros_like(value), "--", color="green")
plt.show()
Scipy Find Peaks
这就是如何使用 Python SciPy 的方法*find_peaks()*找到信号的峰值。
科学发现山峰突起
Python SciPy 有一个方法*peak_prominence()*,该方法计算峰值与其最低轮廓线之间的垂直距离，并与信号的周围基线进行比较。
下面给出了语法。
scipy.signal.peak_prominences(x, wlen=None, peaks)
其中参数为:
- x(序列): 用于接受需要寻找峰值的信号。
- wlen(int): 它用于指定采样窗口长度。
- 峰值(序列):x 中的峰值指数
方法*peak_prominence()*返回 ndarray 类型的*prominences*(每个峰值)和 left-right bases 。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
%matplotlib inline
使用下面的代码生成一个信号。
array_data = np.linspace(0, 5 * np.pi, 1100)
sig = np.sin(array_data) + 0.5 * np.sin(1.7 * array_data)
使用以下代码确定所有峰的显著性。
sig_peaks, _ = signal.find_peaks(sig)
promin = signal.peak_prominences(sig, sig_peaks)[0]
promin
现在使用下面的代码计算并绘制每个峰的轮廓线的高度。
contur_height = sig[sig_peaks] - promin
plt.plot(sig)
plt.plot(sig_peaks, sig[sig_peaks], "*")
plt.vlines(x=sig_peaks, ymin=contur_height, ymax=sig[sig_peaks])
plt.show()
Scipy Find Peaks Prominence
这就是如何使用 Python SciPy 的方法*peak_prominences()*找到峰的日珥。
Scipy 查找峰值 cwt
Python SciPy 有一个方法*find_peaks_cwt()*，它使用*Wavelet transformation*在一维数组中寻找峰值。但是 “什么是小波变换？” 使用一对滤波器将 N 个样本的信号分解成低频带和高频带。每个频带都是两倍欠采样，每个频带有 N/2 个样本。
下面给出了语法。
scipy.signal.find_peaks_cwt(vector, wavelet=None, widths, max_distances=None, window_size=None, gap_thresh=None, min_snr=0, min_length=None, noise_perc=9)
其中参数为:
- vector(ndarray): 在一维数组中寻找波峰。
- 小波(可调用): 取两个参数后，必须返回一个一维数组与向量进行卷积。第一个参数指定输出小波数组中的点数，而第二个参数指定小波的尺度。
- widths(): 要计算 CWT 矩阵，请使用单一宽度或一维宽度数组。
- 最大距离(ndarray): 仅当第[n]行的相对最大值在第[n+1]行的相对最大值的最大距离[n]内时，脊线在每一行都是连通的。
- window _ size(int):要计算噪底，指定窗口的大小。
- gap _ thresh(float):如果在最大距离内没有找到相对最大值，就会有间隙。如果超过
gap_thresh点而没有新的相对最大值，脊线终止。 - min_snr(浮点): 最小信噪比。
- min_length(int): 一条脊线的最小长度必须是可接受的。
- noise _ PERC(float):本底噪声是使用低于其噪声被考虑的数据点的百分比来计算的。
方法*find_peaks_cwt()*返回 te peak_indices 。
让我们通过下面的步骤来了解一个示例:
使用下面的 python 代码导入所需的库。
from scipy.signal import find_peaks_cwt
import numpy as np
使用下面的代码，使用方法*np.sin()*生成数组元素并在该数组上应用函数 sin。
x_data = np.arange(0, np.pi, 0.06)
sin_data = np.sin(x_data)
使用以下代码计算峰值指数或峰值。
peak_indices = signal.find_peaks_cwt(sin_data, np.arange(2,11))
peak_indices, x_data[peak_indices], sin_data[peak_indices]
Scipy Find Peaks cwt
这就是如何使用 Python SciPy 的方法*find_peaks_cwt*找到峰值。
阅读: Scipy 优化–实用指南
Scipy 发现峰宽
Python SciPy 有一个方法*peak_widths()*可以确定每个信号峰值的宽度。
下面给出了语法。
scipy.signal.peak_widths(x, rel_height=0.3, peaks, wlen=None, prominence_data=None)
其中参数为:
- x(序列): 它用来接受信号。
- wlen(int): 它用于指定采样窗口长度。
- 峰值(序列):x 中的峰值指数
- rel _ height(float):选择峰宽的相对高度，以其突出度的百分比表示。峰的宽度在其最低轮廓线处计算为 1.0，日珥高度的一半计算为 0.5。
- prominence _ data(tuple):当用相同的参数 x 和 peaks 调用时，一个 3 数组的元组匹配 peak prominences 的结果。
方法*peak_widths()*返回 widths(样品峰宽) ， widths_height(用于计算宽度的轮廓线的高度。)**``right_ips, left_ips(各评价高度的水平线左右交点的插补位置) 。
让我们按照以下步骤来看一个例子:
使用下面的 python 代码导入所需的库。
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
%matplotlib inline
使用下面的代码生成一个信号。
array_data = np.linspace(0, 5 * np.pi, 1100)
sig = np.sin(array_data) + 0.5 * np.sin(1.7 * array_data)
使用以下代码确定所有峰的宽度。
sig_peaks, _ = signal.find_peaks(sig)
promin = signal.peak_prominences(sig, sig_peaks)[0]
promin
使用以下代码绘制信号、峰值和等高线的宽度。
plt.plot(sig)
plt.plot(sig_peaks, sig[sig_peaks], "*")
plt.hlines(*half_peak_res[1:], color="C4")
plt.hlines(*full_peak_res[1:], color="C5")
plt.show()
Scipy Finds Peak Width
这就是如何使用 Python SciPy 的方法*peak_widths()*计算峰宽。
阅读:Python Scipy FFT【11 个有用的例子】
科学发现高峰和低谷
在 Python SciPy 中，没有内置的方法来查找信号的波峰和波谷，这里我们将使用模块scipy.signal中的方法*argrelextrema()*手动执行这项任务。
要找到信号流的波峰和波谷，请执行以下步骤:
使用下面的 python 代码导入所需的库。
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')
from scipy.signal import argrelextrema
%matplotlib inline
使用下面的代码生成数据。
x_data = np.arange(start = 0, stop = 30, step = 1, dtype='int')
y_data = np.random.random(30)*5
使用下面的代码计算峰值。
peaks_ind = argrelextrema(y_data, np.greater)
peaks_ind = peaks_ind[0]
使用下面的代码计算山谷。
valleys_ind = argrelextrema(y_data, np.less)
valleys_ind = valleys_ind[0]
用我们使用下面的代码生成的峰值和谷值数据绘制图表。
(fig, ax) = plt.subplots()
ax.plot(x_data, y_data)
x_peak = peaks_ind
y_peak = y_data[peaks_ind]
ax.plot(x_peak, y_peak, marker='*', linestyle='dashed', color='orange', label="peaks")
x_valley = valleys_ind
y_valley = y_data[valleys_ind]
ax.plot(x_valley, y_valley, marker='*', linestyle='dashed', color='blue', label="Valleys")
Scipy Find Peaks and Valleys
这就是如何在 Python SciPy 中找到信号的波峰和波谷。
科学发现峰值最小值
我们已经学习了如何使用 Python Scipy 库的方法*find_peaks()*找到信号的峰值或最大值。但在这一部分，我们将找到给定信号的最小值或谷值。
要找到信号或给定数据的最小值，请遵循以下步骤:
使用下面的 python 代码导入所需的库。
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')
from scipy.signal import argrelextrema
按照下面的代码，使用随机数据创建一个信号。
array_data = np.arange(start = 0, stop = 40, step = 1, dtype='int')
y_array_data = np.random.random(40)*5
使用下面的代码计算信号的最小值。
minima_ind = argrelextrema(y_array_data, np.less)
minima_ind = minima_ind[0]
minima_ind
用下面的代码在图上标出计算出的最小值。
(fig, ax) = plt.subplots()
ax.plot(array_data, y_array_data)
x_minima = minima_ind
y_minima = y_array_data[minima_ind]
ax.plot(x_minima, y_minima, marker='*', linestyle='dashed', color='green', label="Minima")
Scipy Find Peaks Minima
这就是如何使用 Python SciPy 的方法*argrelextrema()*找到信号或数据的最小值。
另外，看看更多的 Python Scipy 教程。
- Python Scipy 卡方检验
- Python Scipy Lognormal
- Python Scipy 指数
- Scipy Stats Zscore +示例
- Scipy Convolve–完整指南
- 敏感信号——有用教程
- Scipy Integrate +示例
因此，在本教程中，我们学习了“ Scipy Find Peaks ”并涵盖了以下主题。
- 科学发现峰值
- 科学发现了突出的顶峰
- Scipy 查找峰值 cwt
- 科学发现高峰和低谷
- 科学发现峰值最小值
- Scipy 发现峰宽
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scipy Integrate +示例
在这个 Python 教程中，我们将学习“ Scipy Integrate ”，在这里我们将学习如何使用集成方法来解决集成问题。此外，我们还将讨论以下主题。
- Scipy 集成
- 科学整合辛普森
- 立体整体梯形
- Scipy 集成四路
- Scipy 集成 Odeint
- Scipy 集成求解 _Ivp
- 积体积体芯片
目录
- 科学整合
- Scipy integrated trap zoid
- 科学整合辛普森
- Scipy 集成四通道
- Scipy Integrate Odeint
- Scipy Integrate Solve_Ivp
- Scipy 积分累计
科学整合
Scipy 子模块*scipy.integrate*包含了许多解决 Python 中积分或微分方程相关问题的方法。它有一个预定义的函数和方法来解决积分或微分方程数学问题。
要了解这个子模块中可用的集成技术，请使用下面的代码。
from scipy import integrate
print(help(integrate))
Scipy integrate
在上面的输出中，当我们滚动浏览时，它显示了本模块中所有的积分或微分技术、方法和函数。
阅读:科学统计-完整指南
Scipy integrated trap zoid
*TrapeZoid*规则是一种积分技术，通过将总面积分成一个更小的梯形来计算曲线下的面积。它基于指定的轴集成给定的函数*y(x)*。
下面给出了在 Python 中使用它的语法。
scipy.integrate.trapezoid(y, x=None, dx=1.0, axis=- 1)
其中参数为:
- y(array_data): 表示我们要积分作为输入的数组。
- x(array_data): 用于指定与 y 值相关的采样点。
- dx(标量): 用于指定不使用
*x*时采样点之间的间距。 - 轴(int): 它定义了我们要在哪个轴上执行积分。
方法*trapezoid()*返回 float 类型的值*trapz*，该值是近似的整数值。
让我们以 Python 中的以下步骤为例:
导入所需的库。
from scipy.integrate import trapezoid
创建代表*y*数据的数组值，并将其传递给方法。
trapezoid([5,8,10])
Scipy Integrate Trapzoid
通过应用梯形法则，输出显示积分值*15.5* 。
科学整合辛普森
Scipy 有一个计算积分近似值的方法*simpson()*。此方法存在于子模块*scipy.integrate*中。
下面给出了在 Python 中使用它的语法。
scipy.integrate.simpson(y, x=None, dx=1.0, axis=- 1, even='avg')
其中参数为:
- y(array_data): 表示我们要积分作为输入的数组。
- x(array_data): 用于指定与 y 值相关的采样点。
- dx(标量): 用于指定不使用
*x*时采样点之间的间距。 - 轴(int): 它定义了我们要在哪个轴上执行积分。
- 偶数(字符串): 用于指定两个结果平均值的梯形法则，第一个和最后一个区间。
让我们以下面的步骤为例:
导入所需的模块，如以下代码所示。
import numpy as np
from scipy.integrate import simpson
使用下面的代码创建一个数据和样本点的数组。
array_data = np.arange(5,15)
sample_pnt = np.arange(5,15)
使用下面的 Python 代码，通过方法*simpson()*计算积分。
simpson(array_data,sample_pnt)
Scipy Integrate Simpson
输出显示数组的积分值，给定的采样点为85.5T3。
阅读: Scipy 旋转图像+示例
Scipy 集成四通道
Scipy 在子模块*scipy.integrate*中有一个方法*quad()*，它计算 Python 中从无限区间 a 到 b 的给定函数的定积分。
下面给出了语法。
scipy.integrate.quad(func, a, b, args=(), full_output=0)
其中参数为:
- func(函数): 用于指定用于积分计算的函数。该函数可以是下列形式之一。
- 双功能(双 y)
- double func(double y，void *user_data)
- double func(int m，double *yy)
- double func(int m，double *yy，void *user_data)
- (浮点): 用于指定积分的下限。
- b(浮点): 用于指定积分的上限。
- args(tuple): 如果我们想给一个函数传递额外的参数，那么就使用这个参数。
- full _ output(int):非零值用于获取集成信息的字典。
该方法返回三个重要结果*y*整数值，*abserr*绝对误差的估计值，infodict包含附加信息的字典。
让我们以下面的步骤为例:
使用下面的 Python 代码导入所需的库。
from scipy.integrate import quad
使用 lambda 函数创建一个函数，并定义间隔，如下面的代码所示。
n3 = lambda n: n**3
a = 0
b = 5
现在使用下面的代码计算函数的积分。
quad(n3, a, b)
Scipy Integrate Quad
输出显示函数n³(n 的 3 次方)的定积分值为*156.25000*。
Scipy Integrate Odeint
Scipy 子模块*scipy.integrate*包含了整合常微分方程的方法*odeint()*。
下面给出了在 Python 中使用它的语法。
scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, printmessg=0)
其中参数为:
- func: 它计算函数 y 在 t 的导数
- y0(数组): 用于为 y 提供初始条件
- t(数组): 它是一系列时间点
- args: 用来给函数 y 提供额外的参数
- Dfun: 用于一个函数的梯度。
- col _ deriv(boolean):对于真值
*Dfun*定义导数向下到列，否则为假时跨越到行。 - print messg(boolean):用于打印汇聚报文。
该函数包含许多参数，但上面我们只解释了常见的参数。
方法*odient()*返回两个值y,它们是包含每个时间 t 的 y 值的数组，以及用于附加输出信息的*infodict*。
让我们以下面的步骤为例:
导入所需的库。
from scipy.integrate import odeint
import matplotlib.pyplot as plt
import numpy as np
使用下面的代码定义等式。
def diff_model(y,t):
k = 0.5
dydt = -k * y
return dydt
使用下面的代码创建一个初始条件。
y0 = 3
使用下面的代码创建一系列时间点。
t = np.linspace(0,15)
通过使用下面的代码提供参数来求解创建的方程。
y = odeint(diff_model,y0,t)
现在用下面的代码画出解决方案。
plt.plot(t,y)
plt.xlabel('time')
plt.ylabel('y(t)')
plt.show()
Scipy Integrate Odeint
这就是如何积分常微分方程。
阅读:科学常数
Scipy Integrate Solve_Ivp
Scipy 有一个方法*solve_ivp()*，它根据提供的初始值整合一个常微分方程系统。
下面给出了在 Python 中使用它的语法。
scipy.integrate.solve_ivp(fun, t_span, y0, method='BDF', t_eval=None, dense_output=False, events=None, vectorized=True, args=None)
其中参数为:
- fun(可调用): 它在系统的右手边。调用函数的签名是 fun(x，z ),其中 x 表示标量，z 是以两种方式表示形状的数组。
- t_span(二元组浮点): 表示从 T0 到 T1 积分的区间。
- y0(array _ data like shape(n)):用于指定初始状态。
- 方法(string 或 odsolver): 用于指定使用哪种积分方法，如 RK45、Radau、RK23、DOP853、BDF、LSODA。
- t _ eval(array _ data):用于指定存储计算出的解的时间。
- dense _ output(boolean):用于指定我们是否要计算连续解。
- 事件(可调用): 用于跟踪事件。
- 矢量化(布尔): 用于指定我们是否要以矢量化的方式实现函数。
- args(tuple): 传递多余的参数。
该函数返回包含许多值的 bunch 对象，但它有两个重要的值，即 y 和 t。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.integrate import solve_ivp
使用下面的代码创建一个指数衰减函数。
def exp_decay(t, y): return -1.0 * y
现在使用下面的代码对指数衰减函数应用方法*solve_ivp()*。
solution = solve_ivp(exp_decay, [5, 15], [4, 6, 10])
检查存储在解决方案中的*t*值。
solution.t
检查存储在解决方案中的*y*值。
solution.y
Scipy Integrate Solve_Ivp
这就是如何根据提供的初值积分一个常微分方程组。
阅读: Scipy 优化–实用指南
Scipy 积分累计
*cumtrapez*该规则是一种积分技术，借助梯形规则对给定函数 y(x)进行累积积分。
下面给出了语法。
scipy.integrate.cumtrapz(y, x=None, dx=1.0, axis=- 1, intial=None)
其中参数为:
- y(array_data): 表示我们要积分作为输入的数组。
- x(array_data): 用于指定与 y 值相关的采样点。
- dx(标量): 用于指定不使用
*x*时采样点之间的间距。 - 轴(int): 它定义了我们要在哪个轴上执行积分。
- 初始值(标量): 用来给函数提供初始值。
方法*trapezoid()*返回 ndarray 类型的值*res*。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.integrate import cumtrapz
import numpy as np
使用下面的代码创建变量【sample _ pts】作为样本点，创建变量 y ³ 用于积分。
sample_pts = np.arange(5, 30)
y_func = np.power(sample_pts, 3)
使用下面的代码对函数使用方法*cumtrapz()*。
cumtrapz(y_func,sample_pts)
Scipy Integrate CumTrapz
这就是如何用方法*cumtrapz()*积分给定函数。
另外，看看更多的 SciPy 教程。
- Python Scipy 特辑
- 敏感信号——有用教程
- Scipy Ndimage Rotate
- Python Scipy Stats 峰度
- Python Scipy 卡方检验
- Python Scipy Stats multivarial _ Normal
- Scipy 正态分布
在本教程中，我们已经了解了" Scipy Integrate "并且我们还讨论了以下主题。
- Scipy 集成
- 科学整合辛普森
- 立体整体梯形
- Scipy 集成四路
- Scipy 集成 Odeint
- Scipy 集成求解 _Ivp
- 积体积体芯片
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
scipy Linalg–有用的指南
在这个 Python 教程中，我们将学习“ Scipy Linalg ”。在这里我们将学习如何解决线性代数问题。此外，我们还将讨论以下主题。
- Scipy Linalg
- Scipy Linalg(科学怪人)
- 西比·林格尔
- Scipy Linalg Lu
- Scipy Linalg Svd.
- Scipy Linalg Solve
- Scipy Linalg Qr
- Scipy Linalg Inverse
- Scipy Linalg Norm
- 西皮·里纳尔格·乔莱斯基
目录
- Scipy Linalg
- 西比林藻卵
- 草履虫八号】T1
- Scipy Linalg Lu
- Scipy Linalg Svd
- Scipy Linalg Solve
- Scipy Linalg Qr
- Scipy Linalg inverse
- Scipy Linalg Norm
- 斯皮·里纳尔格·乔莱斯基
Scipy Linalg
Python Scipy 中的*scipy.linalg*模块用于解决线性代数问题。我们可以使用这个库来解决方程、矩阵、特征值和特殊的矩阵问题等。
它有多种解决线性代数问题的方法。*linalg*库中的所有方法被分成以下几个部分:
- 特征值问题
- 矩阵函数
- 基础
- 分解
- 草图和随机投影
- 低级例程
- 矩阵方程求解器
- 特殊矩阵
在接下来的小节中，我们将学习模块*scipy.linalg*最常见的方法。
西比林藻卵
Python Scipy 在模块*scipy.linalg*中有一个方法*eig()*来处理常见的特征值问题。
下面给出了语法。
scipy.linalg.eig(a, b=None, right=False, left=True, overwrite_a=True, overwrite_b=True, check_finite=False, homogeneous_eigvals=True)
其中参数为:
- a(array_data): 提供实矩阵或复矩阵作为计算特征向量和特征值的输入。
- b(array_data): 输入右侧矩阵。
- 右(布尔): 计算并得到右特征向量。
- 左(布尔): 计算并得到左特征向量。
- 覆盖 _a(布尔): 覆盖
*a*。 - 覆盖 _b(布尔): 覆盖
*b*。 - check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
- 【齐次 _ 特征值(布尔): 获取齐次坐标中的特征值
方法*eig()*返回复数 ndarray 或 double 类型的 w(特征值) 、 vr(规范化的右向量) 和 vl(规范化的左向量)
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
import numpy as np
from scipy.linalg import eig
使用下面的代码创建一个矩阵形式的数据数组。
mat_data = np.array([[-1.,0],[0.2,1]])
使用以下代码将创建的矩阵数据传递给方法eig()。
eig(mat_data)
Scipy Linalg Eig
这就是如何使用 Python Scipy 的方法*eig()*计算特征值和特征向量。
阅读: Scipy 卷积器
草履虫八号】T1
Python Scipy 在模块*scipy.linalg*中有一个方法*eigh()*来处理实对称或厄米矩阵的标准普通特征值问题。
下面给出了语法。
scipy.linalg.eigh(a, b=None, eigvals_only=True, lower=False, overwrite_a=True, overwrite_b=True, turbo=False, eigvals=None, type=1, check_finite=False, subset_by_index=None, subset_by_value=None, driver=None)
其中参数为:
- a(array_data): 提供实矩阵或复矩阵作为计算特征向量和特征值的输入。
- b(array_data): 输入右侧矩阵。
- lower(bool): 相关数组的数据是从 a 的下三角还是上三角中选取的
- egvals _ only(boolean):只计算特征值，不计算特征向量。默认情况下，两者都是经过计算的。
- 覆盖 _a(布尔): 覆盖
*a*。 - 覆盖 _b(布尔): 覆盖
*b*。 - check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
- subset _ by _ index(iterable):使用可迭代的二元定义开始和结束特征值索引。
- subset _ by _ value(iterable):用一个可迭代的二元来定义半区间只求特征值。
方法*eigh()*以 ndarray 类型的递增大小返回 w(选定的特征值) 。
让我们按照下面的步骤举例:
使用下面的 python 代码导入所需的库。
import numpy as np
from scipy.linalg import eigh
使用下面的代码创建一个矩阵形式的数据数组。
matrix_data = np.array([[5, 3, 6, 1], [5, 1, 3, 0], [2, 6, 5, 1], [1, 5, 2, 2]])
使用以下代码将创建的矩阵数据传递给方法*eigh()*。
eigh(matrix_data)
Scipy Linalg Eigh
这就是如何使用 Python Scipy 的方法*eigh()*计算特征值。
Scipy Linalg Lu
Python Scipy 在模块*scipy.linalg*中有一个方法*lu()*来计算矩阵的旋转 Lu 分解。
下面给出了语法。
scipy.linalg.lu(a, permute_l=True, check_finite=False, overwrite_a=True,)
其中参数为:
- a(数组 _ 数据): 对数组进行分解。
- permute_l(布尔): 做乘法
- 覆盖 _a(布尔): 覆盖
a。 - check _ finit(boolean):检查提供的作为输入的矩阵是否有有限个数字。
方法返回 p(置换矩阵) ， l(下三角) ， ***u(上三角)*permute_l equal to false*， pl(置换 L 矩阵) ， ***u(上三角) **`permute_l equal to true`````
让我们通过下面的步骤来了解一个示例:
使用下面的 python 代码导入所需的库。
import numpy as np
from scipy.linalg import lu
使用下面的代码创建一个数据数组。
array_data = np.array([[8, 7, 2, 5], [2, 8, 5, 2], [6, 6, 5, 7], [4, 5, 8, 4]])
使用下面的代码将创建的数据数组传递给方法*lu()*。
permute_mat,lower_tri,upper_tri = lu(array_data)
print('Permutation matrix',permute_mat)
print('Lower triangular',lower_tri)
print('Upper triangular',upper_tri)
Scipy Linalg Lu
查看输出，结果是*Permutaton matrix*、*Lower triangular*和*Upper triangular*。
这就是如何使用*lu() for Lu decomposition of a* 矩阵的方法。
阅读: Scipy 正态分布
Scipy Linalg Svd
Python Scipy 在模块*scipy.linalg*中有一个方法*svd()*用于奇异分解值。
下面给出了语法。
scipy.linalg.svd(a, compute_uv=False, full_matrices=False, overwrite_a=True, check_finite=False, lapack_driver='gesdd')
其中参数为:
- a(array_data): 是用于分解的矩阵。
- compute_uv(布尔): 计算除 s 之外的 v 和 uh
- full _ matrix(布尔): 对于真值，v 和 uh 的形状为(M，M) (N，N)，对于假值，形状为(M，K)和(K，N)。
- 覆盖 _a(布尔): 覆盖
a。 - check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
- lapack_driver(gesvd，gesdd): 使用更高效的通用矩形方法或分治方法。
方法*svd()*返回 ndarray 类型的 U(酉矩阵的左奇异向量) ， s(奇异值) 和 vh(酉矩阵的右奇异向量) 。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from numpy.random import default_rng
from scipy.linalg import svd
使用随机生成器 default_rng 通过下面的代码生成一个数据数组。
random_numgen = default_rng()
m, n = 12, 8
array_data = random_numgen.standard_normal((m, n)) + 1.j*random_numgen.standard_normal((m, n))
使用下面的代码对数据数组执行 svd。
U, s, Vh = svd(array_data)
print("left singular vectors of Unitary matrix",U.shape)
print("singular values",s)
print("right singular vectors of Unitary matrix",Vh.shape)
Scipy Linalg Svd
这就是如何使用方法*svd()*对数组进行奇异分解。
Scipy Linalg Solve
Python Scipy 在模块*scipy.linalg*中有一个方法*solve()*来处理与线性方程相关的问题，例如*ax = b*，这意味着这个方程是为方阵*a*的值*x*求解的。
下面给出了语法。
scipy.linalg.solve(a, b, overwrite_a=True, lower=True, debug=None, overwrite_b=True, sym_pos=True, assume_a='gen', check_finite=False, transposed=True)
其中参数为:
- (array _ data):接受方形数据作为输入。
- b(array_data):输入数据的右边。
- lower(bool): 相关数组的数据是从 a 的下三角还是上三角中选取的
- 覆盖 _a(布尔): 覆盖 a
- 覆盖 _b(布尔): 覆盖
*b*。 - check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
- sym _ post(boolean):而不是
*sym_pos*使用参数*assume_a = pos*，因为*sym_pos*已经折旧。该参数认为参数*a*提供的值是非对称正定的。 - 它应该包含什么 值在上面的参数中有解释。
- 转置(布尔): 如果为真，则
a转置，如*a*T x = b*。
*方法solve返回 ndarray 类型的 x(这是一个解数组) 和发生的错误。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.linalg import solve
import numpy as np
给定 x 和 y 的值，找出 z 的值，首先，使用下面的代码创建 x 和 y 的数据数组。
x = np.array([[4, 3, 0], [2, -2, 0], [1, 0, 5]])
y = np.array([1, 3, -4])
使用下面的代码求解 z 的 x 和 y。
solve(x,y)
Scipy Linalg Solve
这就是如何用*solve()*的方法解决线性方程问题。
读取:敏感信号
Scipy Linalg Qr
我们将讨论矩阵的 QR 分解或 QR 分解。QR 分解是矩阵的分解，例如“A”分解成“A=QR”，其中 R 是上三角矩阵，Q 是正交的。我们用 Python SciPy 方法*scipy.linalg.qr()*函数分解矩阵。
下面给出了语法。
scipy.linalg.qr(a, overwrite_a=True, lwork=None, mode='full', pivoting=True, check_finite=False)
其中参数为:
- a(array_data): 输入我们要分解的矩阵。
- 覆盖 _a(布尔): 覆盖
a。 - check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
- lwork(int): 工作数组的大小，
lwork >= a.shape[1]。如果未指定或指定了-1，则确定最佳大小。 - 模式: 确定将同时返回 Q 和 R ('full '，这是默认值)，仅返回 R ('r ')，或者同时返回 Q 和 R，但按经济规模计算。
- 旋转(布尔): 旋转是否应该包含在因子分解中以进行等级揭示 qr 分解。如果旋转，如上所述进行分解
*A P = Q R*，但是选择 P，使得 R 的对角线不增加。
该方法返回 ndarray 或 float 或 int 类型的 Q(其形状为 M，M) ，R(M，N 的形状) 和P(N 的形状) 。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
import numpy as np
from scipy.linalg import qr
创建一个随机数生成器的对象，并使用下面的代码从正态分布中生成一个样本。
random_gen = np.random.default_rng()
data = random_gen.standard_normal((7, 5))
data
对数据执行qr并使用以下代码检查形状。
shape_q, shape_r = qr(data)
print('Shape of q',shape_q.shape)
print('Shape of r',shape_r.shape)
Scipy Linalg Qr
这就是如何使用 Python Scipy 的方法*qr()*进行 QR 分解。
Scipy Linalg inverse
Python SciPy 在模块*sicpy.linalg*中包含一个方法*inv()*,用于确定矩阵的逆矩阵。
下面给出了语法。
scipy.linalg.inv(a, overwrite_a=True, check_finite=False)
其中参数为:
- a(array_data): 输入我们要求逆的矩阵。
- 覆盖 _a(布尔): 覆盖
a。 - check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
方法*inv()*返回 inv(矩阵的逆) 。
让我们以下面的步骤为例:
使用下面的代码导入所需的库。
from scipy.linalg import inv
import numpy as np
创建一个矩阵，并用下面的代码求逆。
mat = np.array([[2., 1.], [4., 3.]])
inv(mat)
Scipy Linalg Inverse
这就是如何使用 Python SciPy 的方法*inv()*对给定矩阵求逆。
Scipy Linalg Norm
Python SciPy 有一个从 8 种不同形式返回矩阵范数的方法norm()。
下面给出了语法。
scipy.linalg.norm(a, axis=None, ord=None, check_finite=True, keepdims=True)
其中参数为:
- a(array_data): 输入的数组除非 ord 为 None，否则 axis 必须为 None，a 必须为 1 维或 2 维，如果 axis 和 ord 都为 None，则返回 a.ravel 2-norm。
- 轴(2 元组的 int，int): 如果轴是整数，则指定要计算向量范数的轴。如果轴是二元组，则指定保存二维矩阵的轴，并计算这些矩阵的矩阵范数。
- ord(int，inf): 用于提供定额订单。
- check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
- keepdims(布尔): 如果设置为真，则被赋范的轴作为尺寸为 1 的尺寸留在结果中。
方法*norm()*返回给定矩阵的范数。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.linalg import norm
import numpy as np
创建一个矩阵形式的数据数组，将使用下面的代码计算其范数。
array_data = np.arange(8) - 3.0
array_data
使用下面的代码计算上面创建的矩阵或数据数组的范数。
norm(array_data)
Scipy Linalg Norm
这就是如何使用 Python SciPy 的方法*norm()*计算给定矩阵的范数。
阅读: Scipy 优化–实用指南
斯皮·里纳尔格·乔莱斯基
Python SciPy 有一个方法*cholesky()*，它返回埃尔米特正定矩阵 A 的乔莱斯基分解*A=LL or A=UU*。
下面给出了语法。
scipy.linalg.cholesky(a, lower=True, overwrite_a=True, check_finite=False)
其中参数为:
- a(数组 _ 数据): 对数组进行分解。
**lower(bool):**相关数组的数据是从 a 的下三角还是上三角中选取的- 覆盖 _a(布尔): 覆盖
a。 - check _ finite(boolean):检查提供的作为输入的矩阵是否有有限个数字。
方法*cholesky()*返回 ndarray 类型的c(上三角形或下三角形的 Cholesky 因子)。
让我们以下面的步骤为例:
使用下面的 python 代码导入所需的库。
from scipy.linalg import cholesky
import numpy as np
使用下面的代码创建一个矩阵。
m = np.array([[2,-1j],[2j,2]])
使用下面的代码计算矩阵的 Cholesky。
cholesky(m,lower = True)
Scipy Linalg Cholesky
这是如何使用 Python SciPy 的方法*cholesky()*计算给定矩阵的 Cholesky。
另外，看看更多的 Scipy 教程。
- Python Scipy 特辑
- Python Scipy 特征值
- Python Scipy 衍生的数组
- Scipy 常量–多个示例
- Scipy Sparse–有用的教程
- Python Scipy Matrix +示例
因此，在本教程中，我们已经了解了" Scipy Linalg "并涵盖了以下主题。
- Scipy Linalg
- Scipy Linalg(科学怪人)
- scipy linalg 号文件。
- Scipy Linalg Lu
- Scipy Linalg Svd.
- Scipy Linalg Solve
- Scipy Linalg Qr
- Scipy Linalg Inverse
- Scipy Linalg Norm
- 西皮·里纳尔格·乔莱斯基
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Scipy 杂项+示例
在这个 Python 教程中，我们将学习“ Scipy Misc 并讨论与之相关的多个例子。此外，我们将讨论以下主题。
- Scipy Misc
- Scipy 杂项信息
- Scipy Misc imsave
- Scipy Misc toimage
- Scipy 杂项衍生物
- Scipy Misc imresize
- Scipy 杂项梳
- Scipy 杂项上升
- Scipy 杂项脸
- Scipy 杂项因子
目录
- Scipy Misc
- 科学杂项信息
- Scipy Misc imsave
- Scipy Misc toimage
- 科学杂项导数
- Scipy Misc imresize
- Scipy 杂项梳
- 科学杂项上升
- Scipy Misc face
- 科学杂项阶乘
Scipy Misc
在 Scipy 中有一个模块*scipy.misc*也就是*Miscellaneous routines*，它有不同的不属于任何特定模块的实用程序或方法。
它有五种不同用途的五种方法，如下所示。
- 【central _ diff _ weights():求给定中心导数的 Np-点的权重。
- face(): 返回浣熊脸，大小为 1024 x 768。
- ascent(): 它返回大小为 512 x 512 的 8 位灰度位深度，这是用于演示目的的派生图像。
- 【心电图(): 用于加载心电图作为一维信号。
- 导数(): 返回给定函数在某一点的第 n 阶导数。
在本教程的后面，我们将分别学习上述方法。
另外，检查:科学常数
科学杂项信息
Scipy 版本 1.2.0 中删除了用于从文件中读取图像的 Scipy 方法*imread()*。该方法存在于另一个名为*imageio*的库中。所以在这里我们将安装这个库并读取一个图像。
下面给出了语法。
imageio.imread(file_path)
其中*file_path*是我们想要读取的图像的路径。
打开一个新的 Jupiter 笔记本或使用 cmd 在计算机上安装库，如下所示步骤:
!pip install imageio
使用下面的代码导入库。
import imageio
import matplotlib.pyplot as plt
%matplotlib inline
使用imread()方法读取图像。
image = imageio.imread('keith_tanner.jpg')
上面的代码包含从指定路径读取图像并返回该图像的 ndarray 的方法*imread()*。
现在使用下面的代码，使用子模块*matplotlib.pyplot*的方法*imshow()*查看图像。
plt.figure(figsize=(5,5))
plt.imshow(image)
plt.axis('off')
plt.show()
Scipy Misc imread
这是如何使用方法imread读取图像。
阅读: Scipy 优化
Scipy Misc imsave
用于将图像从数组保存到文件的 Scipy 方法*imsave()*已从 Scipy 版本 1.2.0 中删除。存在于另一个库*imageio*中的方法imwrite()被用来代替那个方法。
下面给出了语法。
imageio.imwrite(uri,array_data,format)
其中参数为:
- uri(string): 是我们要保存的文件的名称。
- array_data: 它是一幅图像的数组值。
- 格式(字符串): 用于指定我们要读取的图像的格式。
让我们以下面的步骤为例:
使用下面的代码导入所需的库。
import numpy as np
import imageio
使用元组创建行和列，如下面的代码所示。
row, col = (10,10)
使用定义的行和列创建数组。
array_data = np.zeros((row,col))
使用下面的代码创建一个图像。
image = imageio.imwrite('creating_img.png',array_data)
Scipy Misc imsave
上面的代码用零值创建了 64 字节的图像。
阅读: Scipy 稀疏
Scipy Misc toimage
Scipy 版本 1.2.0 中删除了用于从数组创建映像的 Scipy 方法*toread()*。存在于另一个库*PIL*中的方法*PIL.mage.fromarray()*被用来代替那个方法。
下面给出了语法。
image.fromarray(obj)
其中参数为:
- obj: 它是一个包含图像值的数组。
让我们通过一个使用以下步骤的示例来理解:
首先，安装库PIL因为这里我们要在 Jupyter 笔记本中安装库。
!pip install Pillow
使用下面的代码导入所需的库。
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
打开任何图像并将其转换为数组。
img = Image.open("severin_candrian.jpg")
array = np.array(img)
使用下面的代码从上面的数组创建一个 PIL 图像。
pilimage=Image.fromarray(array)
使用下面的代码查看图像。
plt.figure(figsize=(5,5))
plt.imshow(pilimage)
plt.axis('off')
plt.show()
Scipy Misc toimage
这是如何从一个给定的数组创建一个图像。
阅读:剪切旋转图像
科学杂项导数
Scipy 模块*misc*包含一个方法*derivative()*,用于查找给定函数在某一点的 n 阶导数。
下面给出了语法。
scipy.misc.derivative(func, x0, dx=1.0, n=1, args=(), order=3)
其中参数为:
- func: 就是我们要求其 n 阶导数的函数。
- x0(浮点): 用于指定求导的点。
- dx(浮点): 用来指定间距。
- n(int): 用于指定导数的阶。
- args(tuple): 它用来提供自变量。
- (int):用来指定要使用的点数。
让我们以下面的代码为例。
from scipy.misc import derivative
def fun(x):
return x`4 + x`3
derivative(fun, 1.0, dx=1e-7)
Scipy Misc derivative
Scipy Misc imresize
模块*scipy.misc*中的方法*imresize()*在 Scipy 版中已被弃用。这里我们可以用库枕的方法*resize()*来代替方法*imresize()*。
下面给出了语法。
image.resize(size)
其中参数*size*获取我们想要调整大小的图像的像素大小。
让我们以下面的步骤为例:
使用下面的代码导入库*pillow*的模块*image*。
import PIL.Image as img
import matplotlib.pyplot as plt
使用下面的代码打开任何我们想要调整大小的图像。
imz = img.open('lesly_derksen.jpg')
使用下面的代码查看和检查图像的大小。
plt.imshow(imz)
imz.size
Scipy Misc imresize
为图像定义新的大小，如下面的代码所示。
new_size = (300,300)
让我们使用下面的代码来减小图像的大小。
imz1= imz.resize(new_size)
现在使用下面的代码来查看缩小后的图像。
plt.imshow(imz1)
imz1.size
Scipy Misc imresize example
阅读: Scipy 信号-有用教程
Scipy 杂项梳
模块*scipy.misc*中的方法*comb()*在 Scipy 版中已被弃用。该方法已经转移到另一个名为*scipy.special*的模块中。这个方法是用来求 k 时刻取的 n 个东西的组合数的。
下面给出了语法。
scipy.special.comb(N, k, exact=False, repetition=False)
其中参数为:
- N(ndarray 或 int): 用来指定事物的数量。
- K(ndarray 或 int): 用于指定取的元素个数。
- exact(boolean): 当其为真时，使用长整数算法计算正确的解，否则以浮点计算近似解。
- 重复(bool): 如果为真，那么它计算有重复的组合数。
让我们以下面的代码为例。
from scipy.special import comb
k_time = np.array([6, 7])
n_things = np.array([15, 15])
comb(n_things, k_time, exact=False)
Scipy Misc comb
阅读: Scipy 卷积-完整指南
科学杂项上升
Scipy 模块 misc 包含另一个方法*ascent()*来获取大小为 512×512 的派生图像的 8 位灰度位深度。
下面给出了语法。
scipy.misc.ascent()
出于演示目的，该方法返回*ascent*类型的 ndarray 图像。
让我们以下面的代码为例。
import scipy.misc as f
import matplotlib.pyplot as plt
asc = f.ascent()
plt.imshow(asc)
Scipy Misc ascent
Scipy Misc face
Scipy 模块 misc 包含另一个方法face()来获得大小为 1024×768 的彩色浣熊脸。
下面给出了语法。
scipy.misc.face(gray=False)
其中参数为:
gray(布尔): 为真时返回 8 位灰度图像，否则返回彩色图像。
让我们按照下面的步骤举个例子。
导入必要的文件。
import scipy.misc as f
import matplotlib.pyplot as plt
使用下面的代码生成浣熊脸。
racoon_face = f.face()
使用下面的代码显示生成的图像。
plt.imshow(racoon_face)
Scipy Misc face
科学杂项阶乘
模块*scipy.misc*中的方法*factorial()*在 Scipy 版中已被弃用。该方法已经转移到另一个名为*scipy.special*的模块中。此方法用于查找数组中包含的一个数字或所有元素的阶乘。
下面给出了语法。
scipy.special.factorial(n, exact=False)
其中参数为:
n(int 或 array): 是我们要求其阶乘的数字或数字数组。
exact(boolean): 当其为真时，使用长整数算法计算正确的解，否则以浮点计算近似解。
让我们举一个例子，用下面的步骤计算一个数组中所有元素的阶乘。
使用下面的代码导入所需的库。
from scipy.special import factorial
import numpy as np
使用下面的方法创建一个数组并将其传递给方法*factorial()*。
array = np.array([5, 6, 7])
factorial(array, exact=False)
Scipy Misc factorial
因此，在本教程中，我们已经了解了" Scipy Misc "并涵盖了以下主题。
- Scipy Misc
- Scipy 杂项信息
- Scipy Misc imsave
- Scipy Misc toimage
- Scipy 杂项衍生物
- Scipy Misc imresize
- Scipy 杂项梳
- Scipy 杂项上升
- Scipy 杂项脸
- Scipy 杂项因子
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
