斐波那契数列编写程序

3.编写程序打印斐波那契数列的第40项。斐波那契数列又称兔子数列，
它的前两项分别是0和1，以后第i项都由第i−2项和第i−1项求和得
到。即斐波那契数列为0,1,1,2,3,5,8,13,21,...

fibonacci = [0, 1]

for i in range(2, 40):
    fib = fibonacci[i-1] + fibonacci[i-2]
    fibonacci.append(fib)

print("斐波那契数列的第40项是：", fibonacci[39])

结果如图, 如有帮助给个采纳谢谢谢笔芯

代码如下:

def fibonacci(n):
  if n <= 1:
    return n
  else:
    return fibonacci(n - 1) + fibonacci(n - 2)


print(fibonacci(40))

a, b = 0, 1
for i in range(38):
    a, b = b, a + b
print(b)



```java
public class Fibonacci {
    public static void main(String[] args) {
        int a = 0, b = 1, c;
        for (int i = 2; i <= 39; i++) {
            c = a + b;
            a = b;
            b = c;
        }
        System.out.println(b);
    }
}

```

这个问题的回答你可以参考下: https://ask.csdn.net/questions/7468918
这篇博客也不错, 你可以看下【机器学习】吴恩达机器学习视频作业-逻辑回归二分类 II
除此之外, 这篇博客: 吴恩达深度学习 | (25) 序列模型专项课程第二周编程作业实验1中的 5.消除词向量的偏差(选做） 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

g = word_to_vec_map['woman'] - word_to_vec_map['man']
print(g)

print ('List of names and their similarities with constructed vector:')

# 一些男孩和女孩的名字
name_list = ['john', 'marie', 'sophie', 'ronaldo', 'priya', 'rahul', 'danielle', 'reza', 'katy', 'yasmin']

for w in name_list:
    print (w, cosine_similarity(word_to_vec_map[w], g))

print('Other words and their similarities:')
word_list = ['lipstick', 'guns', 'science', 'arts', 'literature', 'warrior','doctor', 'tree', 'receptionist', 
             'technology',  'fashion', 'teacher', 'engineer', 'pilot', 'computer', 'singer']
for w in word_list:
    print (w, cosine_similarity(word_to_vec_map[w], g))

接下来我们将使用Boliukbasi et al., 2016.中提到的算法来消除这些向量的偏差。注意一些单词对，如actor/actress 或 grandmother/grandfather有明显的性别关联，而其他单词如receptionist或technology应该是中立的，与性别没什么关联。在进行偏差消除时，我们应该区别对待两种不同类型的词。

中和非性别特定词的偏差

def neutralize(word, g, word_to_vec_map):
    """
    通过将词嵌入投影在与(性别)偏差轴正交的空间上来消除“单词(与性别无关)”的在性别方向上的偏差。
     此功能可确保性别中性词在性别子空间中为零
    
    Arguments:
        word -- 需要消除偏差的词 字符串
        g -- 一维数组 (50,), 对应偏差轴 (如 性别)
        word_to_vec_map -- 词与其嵌入向量的映射字典
    
    Returns:
        e_debiased -- 输入 "word"在消除(性别)偏差后的嵌入表示
    """
    
   
    # 得到word的词嵌入
    e = word_to_vec_map[word]
    
    # 用上述公式计算 e_biascomponent
    e_biascomponent = e.dot(g)/(np.linalg.norm(g)**2)*g
 
    # 中和e，通过减去e_biascomponent
    # e_debiased 应该和它的正交映射相等
    e_debiased = e - e_biascomponent

    
    return e_debiased

e = "receptionist"
print("cosine similarity between " + e + " and g, before neutralizing: ", cosine_similarity(word_to_vec_map["receptionist"], g))

e_debiased = neutralize("receptionist", g, word_to_vec_map)
print("cosine similarity between " + e + " and g, after neutralizing: ", cosine_similarity(e_debiased, g))

性别特定词的均衡算法

均衡算法的线性代数推导有点复杂，详见论文Boliukbasi et al., 2016.下面是一些关键方程：

def equalize(pair, bias_axis, word_to_vec_map):
    """
    按照上述描述的均衡算法，对一对性别特定词进行处理
    
    Arguments:
    pair -- 一对性别特定词 e.g. ("actress", "actor") 
    bias_axis --  一维数组 (50,), 对应偏差轴 (如 性别)
    word_to_vec_map -- 词与其嵌入向量的映射字典
    
    Returns
    e_1 -- 第一个单词均衡后的词向量
    e_2 -- 第二个单词均衡后的词向量
    """

    # 得到单词及其词向量
    w1, w2 = pair
    e_w1, e_w2 = word_to_vec_map[w1],word_to_vec_map[w2]
    
    # 计算 e_w1 和 e_w2 的均值
    mu = (e_w1 + e_w2)/2

    # 计算mu在偏差轴和正交轴上的映射
    mu_B = mu.dot(bias_axis)/(np.linalg.norm(bias_axis)**2) * bias_axis
    mu_orth = mu - mu_B

    # 使用公式 (7) 和 (8) 计算 e_w1B 和 e_w2B 
    e_w1B = e_w1.dot(bias_axis)/(np.linalg.norm(bias_axis)**2) * bias_axis
    e_w2B = e_w2.dot(bias_axis)/(np.linalg.norm(bias_axis)**2) * bias_axis
        
    # 调整 e_w1B 和 e_w2B 的偏差部分 使用公式 (9)和(10)
    corrected_e_w1B = np.sqrt(np.abs(1-np.linalg.norm(mu_orth)**2))*((e_w1B-mu_B)/(np.abs(e_w1-mu_orth-mu_B)))
    
    corrected_e_w2B = np.sqrt(np.abs(1-np.linalg.norm(mu_orth)**2))*((e_w2B-mu_B)/(np.abs(e_w2-mu_orth-mu_B)))

    # 公式(11) (12)
    e1 = corrected_e_w1B + mu_orth
    e2 = corrected_e_w2B + mu_orth
                                                                
    
    
    return e1, e2

print("cosine similarities before equalizing:")
print("cosine_similarity(word_to_vec_map[\"man\"], gender) = ", cosine_similarity(word_to_vec_map["man"], g))
print("cosine_similarity(word_to_vec_map[\"woman\"], gender) = ", cosine_similarity(word_to_vec_map["woman"], g))
print()
e1, e2 = equalize(("man", "woman"), g, word_to_vec_map)
print("cosine similarities after equalizing:")
print("cosine_similarity(e1, gender) = ", cosine_similarity(e1, g))
print("cosine_similarity(e2, gender) = ", cosine_similarity(e2, g))

参考

The debiasing algorithm is from Bolukbasi et al., 2016, Man is to Computer Programmer as Woman is to Homemaker? Debiasing Word Embeddings

The GloVe word embeddings were due to Jeffrey Pennington, Richard Socher, and Christopher D. Manning. (https://nlp.stanford.edu/projects/glove/)

以下回答由chatgpt基于相关博客总结生成:
可以编写一个使用递归方式计算斐波那契数列的程序，代码如下：
```
def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(40))
```
这个程序会递归调用fibonacci()函数，直到计算出斐波那契数列的第40项。但是，这个程序的缺点是计算量非常大，运行时间可能会很长，甚至可能导致计算机崩溃。因此，还可以使用循环方式计算斐波那契数列，代码如下：
```
a, b = 0, 1
for i in range(40):
    a, b = b, a+b
print(a)
```
这个程序会用两个变量a和b来保存斐波那契数列中的前两项。然后，通过循环计算出斐波那契数列的第40项，最终把结果保存在变量a中。这种方式不需要递归调用，计算量小，运行时间短，更加高效。